PHPackages                             fangx/condition - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. fangx/condition

ActiveLibrary[Utility & Helpers](/categories/utility)

fangx/condition
===============

v2.0.0(4y ago)21.2kMITPHPPHP ^7.2.0|^8.0

Since Sep 10Pushed 4y ago1 watchersCompare

[ Source](https://github.com/fangx-packages/condition)[ Packagist](https://packagist.org/packages/fangx/condition)[ RSS](/packages/fangx-condition/feed)WikiDiscussions master Synced 1mo ago

READMEChangelogDependencies (3)Versions (6)Used By (0)

Fangx's Packages
----------------

[](#fangxs-packages)

### Install

[](#install)

Via Composer

```
composer require fangx/condition

```

### Usage

[](#usage)

```
use Fangx\Condition\Condition;
use Fangx\Condition\Fields\ContainsField;
use Fangx\Condition\Fields\EqualsField;
use Fangx\Condition\Fields\ExistsField;
use Fangx\Condition\Fields\GteField;
use Fangx\Condition\Fields\GtField;
use Fangx\Condition\Fields\LteField;
use Fangx\Condition\Fields\LtField;
use Fangx\Condition\Fields\NetworkField;
use Fangx\Condition\Fields\OneOfField;
use Fangx\Condition\Fields\RegexpField;
use Fangx\Condition\Groups\GroupAndNode;
use Fangx\Condition\Groups\GroupNotNode;
use Fangx\Condition\Groups\GroupOrNode;
use PHPUnit\Framework\TestCase;

class ConditionTest extends TestCase
{
    public function testMixNode()
    {
        $node = $this->node();

        $this->assertFalse($node->check());

        $this->assertTrue($node->check(['f-not' => 'ff', 'b-not' => 'bb', 'b-or-1' => 'b1', 'f-or-1' => 'f1', 'ip' => '192.168.128.54']));

        $this->assertEquals('{"and":[{"and":[{"or":[{"equals":{"f-or-1":"f1"}},{"equals":{"f-or-2":"f2"}}]},{"or":[{"equals":{"b-or-1":"b1"}},{"equals":{"b-or-2":"b2"}}]}]},{"and":[{"not":[{"equals":{"f-not":"f"}}]},{"not":[{"equals":{"b-not":"b"}}]}]},{"has_fields":["f-not","b-not"]},{"network":{"ip":"192.168.128.54"}}]}', $node->encode());
    }

    public function testUnpackNode()
    {
        $this->assertEmpty(Condition::unpack([]));

        $node = Condition::unpack($this->node()->pack());

        $this->assertFalse($node->check());

        $this->assertTrue($node->check(['f-not' => 'ff', 'b-not' => 'bb', 'b-or-1' => 'b1', 'f-or-1' => 'f1', 'ip' => '192.168.128.54']));

        $this->assertEquals('{"and":[{"and":[{"or":[{"equals":{"f-or-1":"f1"}},{"equals":{"f-or-2":"f2"}}]},{"or":[{"equals":{"b-or-1":"b1"}},{"equals":{"b-or-2":"b2"}}]}]},{"and":[{"not":[{"equals":{"f-not":"f"}}]},{"not":[{"equals":{"b-not":"b"}}]}]},{"has_fields":["f-not","b-not"]},{"network":{"ip":"192.168.128.54"}}]}', $node->encode());
    }

    public function testDecodeNode()
    {
        $node = Condition::decode($this->node()->encode());

        $this->assertFalse($node->check());

        $this->assertTrue($node->check(['f-not' => 'ff', 'b-not' => 'bb', 'b-or-1' => 'b1', 'f-or-1' => 'f1', 'ip' => '192.168.128.54']));

        $this->assertEquals('{"and":[{"and":[{"or":[{"equals":{"f-or-1":"f1"}},{"equals":{"f-or-2":"f2"}}]},{"or":[{"equals":{"b-or-1":"b1"}},{"equals":{"b-or-2":"b2"}}]}]},{"and":[{"not":[{"equals":{"f-not":"f"}}]},{"not":[{"equals":{"b-not":"b"}}]}]},{"has_fields":["f-not","b-not"]},{"network":{"ip":"192.168.128.54"}}]}', $node->encode());
    }

    public function testGroupAndNode()
    {
        $node = GroupAndNode::create([
            EqualsField::create('f', 'foo'),
            EqualsField::create('b', 'bar'),
        ]);

        $this->assertTrue($node->check(['f' => 'foo', 'b' => 'bar']));
        $this->assertFalse($node->check(['f' => 'foo']));
        $this->assertFalse($node->check(['b' => 'bar']));
        $this->assertFalse($node->check());
        $this->assertEquals('{"and":[{"equals":{"f":"foo"}},{"equals":{"b":"bar"}}]}', $node->encode());
    }

    public function testGroupOrNode()
    {
        $node = GroupOrNode::create([
            EqualsField::create('f', 'foo'),
            EqualsField::create('b', 'bar'),
        ]);

        $this->assertTrue($node->check(['f' => 'foo', 'b' => 'bar']));
        $this->assertTrue($node->check(['f' => 'foo']));
        $this->assertTrue($node->check(['b' => 'bar']));
        $this->assertFalse($node->check());
        $this->assertEquals('{"or":[{"equals":{"f":"foo"}},{"equals":{"b":"bar"}}]}', $node->encode());
    }

    public function testGroupNotNode()
    {
        $node = GroupNotNode::create([
            EqualsField::create('f', 'foo'),
            EqualsField::create('b', 'bar'),
        ]);

        $this->assertFalse($node->check(['f' => 'foo', 'b' => 'bar']));
        $this->assertFalse($node->check(['f' => 'foo1', 'b' => 'bar']));
        $this->assertTrue($node->check(['f' => 'foo1', 'b' => 'bar1']));
        $this->assertFalse($node->check(['f' => 'foo']));
        $this->assertFalse($node->check(['b' => 'bar']));
        $this->assertTrue($node->check());
        $this->assertEquals('{"not":[{"equals":{"f":"foo"}},{"equals":{"b":"bar"}}]}', $node->encode());
    }

    public function testEqualsNode()
    {
        $node = EqualsField::create('f', 'foo');

        $this->assertTrue($node->check(['f' => 'foo']));
        $this->assertFalse($node->check());
        $this->assertEquals('{"equals":{"f":"foo"}}', $node->encode());
    }

    public function testOneOfNode()
    {
        $node = OneOfField::create('f', ['foo', 'fooo']);

        $this->assertTrue($node->check(['f' => 'foo']));
        $this->assertTrue($node->check(['f' => 'fooo']));
        $this->assertFalse($node->check());
        $this->assertEquals('{"one_of":{"f":["foo","fooo"]}}', $node->encode());
    }

    public function testContainsNode()
    {
        $node = ContainsField::create('f', 'hello');

        $this->assertTrue($node->check(['f' => 'hello world']));
        $this->assertFalse($node->check(['f' => 'hi world']));
        $this->assertFalse($node->check());
        $this->assertEquals('{"contains":{"f":"hello"}}', $node->encode());
    }

    public function testGteNode()
    {
        $node = GteField::create('f', 2);

        $this->assertFalse($node->check(['f' => 1]));
        $this->assertTrue($node->check(['f' => 2]));
        $this->assertTrue($node->check(['f' => 3]));
        $this->assertFalse($node->check());
        $this->assertEquals('{"gte":{"f":2}}', $node->encode());
    }

    public function testGtNode()
    {
        $node = GtField::create('f', 2);

        $this->assertFalse($node->check(['f' => 1]));
        $this->assertFalse($node->check(['f' => 2]));
        $this->assertTrue($node->check(['f' => 3]));
        $this->assertFalse($node->check());
        $this->assertEquals('{"gt":{"f":2}}', $node->encode());
    }

    public function testLteNode()
    {
        $node = LteField::create('f', 2);

        $this->assertTrue($node->check(['f' => 1]));
        $this->assertTrue($node->check(['f' => 2]));
        $this->assertFalse($node->check(['f' => 3]));
        $this->assertFalse($node->check());
        $this->assertEquals('{"lte":{"f":2}}', $node->encode());
    }

    public function testLtNode()
    {
        $node = LtField::create('f', 2);

        $this->assertTrue($node->check(['f' => 1]));
        $this->assertFalse($node->check(['f' => 2]));
        $this->assertFalse($node->check(['f' => 3]));
        $this->assertFalse($node->check());
        $this->assertEquals('{"lt":{"f":2}}', $node->encode());
    }

    public function testRegexpNode()
    {
        $node = RegexpField::create('f', '/^\d$/');

        $this->assertTrue($node->check(['f' => 1]));
        $this->assertTrue($node->check(['f' => '1']));
        $this->assertFalse($node->check(['f' => '1.5']));
        $this->assertFalse($node->check());
        $this->assertEquals('{"regexp":{"f":"\/^\\\d$\/"}}', $node->encode());
    }

    public function testHasFieldsNode()
    {
        $node = ExistsField::create('foo', 'bar');

        $this->assertTrue($node->check(['foo' => 'f', 'bar' => 'b']));
        $this->assertFalse($node->check(['foo' => 'f']));
        $this->assertFalse($node->check(['bar' => 'b']));
        $this->assertEquals('{"has_fields":["foo","bar"]}', $node->encode());

        $node = ExistsField::create(['foo', 'bar']);

        $this->assertTrue($node->check(['foo' => 'f', 'bar' => 'b']));
        $this->assertFalse($node->check(['foo' => 'f']));
        $this->assertFalse($node->check(['bar' => 'b']));
        $this->assertEquals('{"has_fields":["foo","bar"]}', $node->encode());
    }

    public function testNetworkNode()
    {
        $this->assertFalse(NetworkField::create('ip', '192.168.128.54')->check());
        $this->assertFalse(NetworkField::create('ip', '192.168.128.54')->check(['ip' => 'ip_address']));
        $this->assertTrue(NetworkField::create('ip', '192.168.128.54')->check(['ip' => '192.168.128.54']));
        $this->assertFalse(NetworkField::create('ip', '192.168.128.54')->check(['ip' => '192.168.128.53']));
        $this->assertTrue(NetworkField::create('ip', '192.168.128.0/8')->check(['ip' => '192.168.128.54']));
        $this->assertFalse(NetworkField::create('ip', '192.168.128.0/8')->check(['ip' => '192.168.110.54']));
        $this->assertTrue(NetworkField::create('ip', '192.168.0.0/16')->check(['ip' => '192.168.128.54']));
        $this->assertTrue(NetworkField::create('ip', '192.168.0.0/16')->check(['ip' => '192.168.110.54']));
        $this->assertFalse(NetworkField::create('ip', '192.168.0.0/16')->check(['ip' => '192.110.110.54']));
        $this->assertFalse(NetworkField::create('ip', 'ip_address')->check(['ip' => '192.110.110.54']));

        $this->assertEquals('{"network":{"ip":"192.168.128.54"}}', NetworkField::create('ip', '192.168.128.54')->encode());
        $this->assertEquals('{"network":{"ip":"192.168.128.0\/8"}}', NetworkField::create('ip', '192.168.128.0/8')->encode());
    }

    private function node()
    {
        return GroupAndNode::create([
            GroupAndNode::create([
                GroupOrNode::create([
                    EqualsField::create('f-or-1', 'f1'),
                    EqualsField::create('f-or-2', 'f2'),
                ]),
                GroupOrNode::create([
                    EqualsField::create('b-or-1', 'b1'),
                    EqualsField::create('b-or-2', 'b2'),
                ]),
            ]),
            GroupAndNode::create([
                GroupNotNode::create([
                    EqualsField::create('f-not', 'f'),
                ]),
                GroupNotNode::create([
                    EqualsField::create('b-not', 'b'),
                ]),
            ]),
            ExistsField::create('f-not', 'b-not'),
            NetworkField::create('ip', '192.168.128.54'),
        ]);
    }
}
```

###  Health Score

30

—

LowBetter than 64% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity17

Limited adoption so far

Community7

Small or concentrated contributor base

Maturity63

Established project with proven stability

 Bus Factor1

Top contributor holds 100% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~85 days

Total

5

Last Release

1735d ago

Major Versions

v1.3.0 → v2.0.02021-08-17

PHP version history (2 changes)v1.0.0PHP ^7.2.0

v2.0.0PHP ^7.2.0|^8.0

### Community

Maintainers

![](https://www.gravatar.com/avatar/48e745eaab94e5e8f347aadc5b74046bb174895188f0507b1d46c0fa6cee6555?d=identicon)[nfangxu](/maintainers/nfangxu)

---

Top Contributors

[![nfangxu](https://avatars.githubusercontent.com/u/33243730?v=4)](https://github.com/nfangxu "nfangxu (13 commits)")

---

Tags

phphyperf

###  Code Quality

TestsPHPUnit

Static AnalysisPHPStan

Code StylePHP CS Fixer

Type Coverage Yes

### Embed Badge

![Health badge](/badges/fangx-condition/health.svg)

```
[![Health](https://phpackages.com/badges/fangx-condition/health.svg)](https://phpackages.com/packages/fangx-condition)
```

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)