18 files changed, 1120 insertions, 0 deletions
diff --git a/vendor/ipl/stdlib/src/Filter.php b/vendor/ipl/stdlib/src/Filter.php
new file mode 100644
index 0000000..9523f1f
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter.php
@@ -0,0 +1,584 @@
+<?php
+
+namespace ipl\Stdlib;
+
+use Exception;
+use InvalidArgumentException;
+use ipl\Stdlib\Filter\All;
+use ipl\Stdlib\Filter\Any;
+use ipl\Stdlib\Filter\Chain;
+use ipl\Stdlib\Filter\Condition;
+use ipl\Stdlib\Filter\Equal;
+use ipl\Stdlib\Filter\GreaterThan;
+use ipl\Stdlib\Filter\GreaterThanOrEqual;
+use ipl\Stdlib\Filter\LessThan;
+use ipl\Stdlib\Filter\LessThanOrEqual;
+use ipl\Stdlib\Filter\Like;
+use ipl\Stdlib\Filter\None;
+use ipl\Stdlib\Filter\Rule;
+use ipl\Stdlib\Filter\Unequal;
+use ipl\Stdlib\Filter\Unlike;
+
+class Filter
+{
+    /**
+     * protected - This is only a factory class
+     */
+    protected function __construct()
+    {
+    }
+
+    /**
+     * Return whether the given rule matches the given item
+     *
+     * @param Rule $rule
+     * @param array<mixed>|object $row
+     *
+     * @return bool
+     */
+    public static function match(Rule $rule, $row)
+    {
+        if (! is_object($row)) {
+            if (is_array($row)) {
+                $row = (object) $row;
+            } else {
+                throw new InvalidArgumentException(sprintf(
+                    'Object or array expected, got %s instead',
+                    get_php_type($row)
+                ));
+            }
+        }
+
+        return (new self())->performMatch($rule, $row);
+    }
+
+    /**
+     * Create a rule that matches if **all** of the given rules do
+     *
+     * @param Rule ...$rules
+     *
+     * @return Chain
+     */
+    public static function all(Rule ...$rules)
+    {
+        return new All(...$rules);
+    }
+
+    /**
+     * Return whether the given rules all match the given item
+     *
+     * @param All $rules
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchAll(All $rules, $row)
+    {
+        foreach ($rules as $rule) {
+            if (! $this->performMatch($rule, $row)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Create a rule that matches if **any** of the given rules do
+     *
+     * @param Rule ...$rules
+     *
+     * @return Chain
+     */
+    public static function any(Rule ...$rules)
+    {
+        return new Any(...$rules);
+    }
+
+    /**
+     * Return whether any of the given rules match the given item
+     *
+     * @param Any $rules
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchAny(Any $rules, $row)
+    {
+        foreach ($rules as $rule) {
+            if ($this->performMatch($rule, $row)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Create a rule that matches if **none** of the given rules do
+     *
+     * @param Rule ...$rules
+     *
+     * @return Chain
+     */
+    public static function none(Rule ...$rules)
+    {
+        return new None(...$rules);
+    }
+
+    /**
+     * Return whether none of the given rules match the given item
+     *
+     * @param None $rules
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchNone(None $rules, $row)
+    {
+        foreach ($rules as $rule) {
+            if ($this->performMatch($rule, $row)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Create a rule that matches rows with a column that **equals** the given value
+     *
+     * @param string $column
+     * @param array<mixed>|bool|float|int|string $value
+     *
+     * @return Condition
+     */
+    public static function equal($column, $value)
+    {
+        return new Equal($column, $value);
+    }
+
+    /**
+     * Return whether the given rule's value equals the given item's value
+     *
+     * @param Equal|Unequal $rule
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchEqual($rule, $row)
+    {
+        if (! $rule instanceof Equal && ! $rule instanceof Unequal) {
+            throw new InvalidArgumentException(sprintf(
+                'Rule must be of type %s or %s, got %s instead',
+                Equal::class,
+                Unequal::class,
+                get_php_type($rule)
+            ));
+        }
+
+        $rowValue = $this->extractValue($rule->getColumn(), $row);
+        $value = $rule->getValue();
+        $this->normalizeTypes($rowValue, $value);
+
+        if (! is_array($rowValue)) {
+            $rowValue = [$rowValue];
+        }
+
+        foreach ($rowValue as $rowVal) {
+            if ($this->performEqualityMatch($value, $rowVal, $rule->ignoresCase())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Create a rule that matches rows with a column that is **similar** to the given value
+     *
+     * Performs a wildcard search if the value contains asterisks.
+     *
+     * @param string $column
+     * @param string|string[] $value
+     *
+     * @return Condition
+     */
+    public static function like($column, $value)
+    {
+        return new Like($column, $value);
+    }
+
+    /**
+     * Return whether the given rule's value is similar to the given item's value
+     *
+     * @param Like|Unlike $rule
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchSimilar($rule, $row)
+    {
+        if (! $rule instanceof Like && ! $rule instanceof Unlike) {
+            throw new InvalidArgumentException(sprintf(
+                'Rule must be of type %s or %s, got %s instead',
+                Like::class,
+                Unlike::class,
+                get_php_type($rule)
+            ));
+        }
+
+        $rowValue = $this->extractValue($rule->getColumn(), $row);
+        $value = $rule->getValue();
+        $this->normalizeTypes($rowValue, $value);
+
+        if (! is_array($rowValue)) {
+            $rowValue = [$rowValue];
+        }
+
+        foreach ($rowValue as $rowVal) {
+            if ($this->performSimilarityMatch($value, $rowVal, $rule->ignoresCase())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Apply equality matching rules on the given row value
+     *
+     * @param mixed $value
+     * @param mixed $rowValue
+     * @param bool $ignoreCase
+     *
+     * @return bool
+     */
+    protected function performEqualityMatch($value, $rowValue, $ignoreCase = false)
+    {
+        if ($ignoreCase && is_string($rowValue)) {
+            $rowValue = strtolower($rowValue);
+            $value = is_array($value)
+                ? array_map(function ($val) {
+                    return strtolower((string) $val);
+                }, $value)
+                : strtolower((string) $value);
+        }
+
+        if (is_array($value)) {
+            return in_array($rowValue, $value, true);
+        } elseif (! is_string($value)) {
+            if (is_string($rowValue)) {
+                $value = (string) $value;
+            }
+        }
+
+        return $rowValue === $value;
+    }
+
+    /**
+     * Apply similarity matching rules on the given row value
+     *
+     * @param string|string[] $value
+     * @param string $rowValue
+     * @param bool $ignoreCase
+     *
+     * @return bool
+     */
+    protected function performSimilarityMatch($value, $rowValue, $ignoreCase = false)
+    {
+        if ($ignoreCase) {
+            $rowValue = strtolower($rowValue);
+            $value = is_array($value)
+                ? array_map('strtolower', $value)
+                : strtolower($value);
+        }
+
+        if (is_array($value)) {
+            return in_array($rowValue, $value, true);
+        }
+
+        $wildcardSubSegments = preg_split('~\*~', $value);
+        if (! $wildcardSubSegments) {
+            $wildcardSubSegments = [];
+        }
+
+        if (count($wildcardSubSegments) === 1) {
+            return $rowValue === $value;
+        }
+
+        $parts = [];
+        foreach ($wildcardSubSegments as $part) {
+            $parts[] = preg_quote($part, '~');
+        }
+
+        $pattern = '~^' . join('.*', $parts) . '$~';
+
+        return (bool) preg_match($pattern, $rowValue);
+    }
+
+    /**
+     * Create a rule that matches rows with a column that is **unequal** with the given value
+     *
+     * @param string $column
+     * @param array<mixed>|bool|float|int|string $value
+     *
+     * @return Condition
+     */
+    public static function unequal($column, $value)
+    {
+        return new Unequal($column, $value);
+    }
+
+    /**
+     * Return whether the given rule's value does not equal the given item's value
+     *
+     * @param Unequal $rule
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchUnequal(Unequal $rule, $row)
+    {
+        return ! $this->matchEqual($rule, $row);
+    }
+
+    /**
+     * Create a rule that matches rows with a column that is **unlike** with the given value
+     *
+     * Performs a wildcard search if the value contains asterisks.
+     *
+     * @param string $column
+     * @param string|string[] $value
+     *
+     * @return Condition
+     */
+    public static function unlike($column, $value)
+    {
+        return new Unlike($column, $value);
+    }
+
+    /**
+     * Return whether the given rule's value is unlike the given item's value
+     *
+     * @param Unlike $rule
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchUnlike(Unlike $rule, $row)
+    {
+        return ! $this->matchSimilar($rule, $row);
+    }
+
+    /**
+     * Create a rule that matches rows with a column that is **greater** than the given value
+     *
+     * @param string $column
+     * @param float|int|string $value
+     *
+     * @return Condition
+     */
+    public static function greaterThan($column, $value)
+    {
+        return new GreaterThan($column, $value);
+    }
+
+    /**
+     * Return whether the given rule's value is greater than the given item's value
+     *
+     * @param GreaterThan $rule
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchGreaterThan(GreaterThan $rule, $row)
+    {
+        return $this->extractValue($rule->getColumn(), $row) > $rule->getValue();
+    }
+
+    /**
+     * Create a rule that matches rows with a column that is **less** than the given value
+     *
+     * @param string $column
+     * @param float|int|string $value
+     *
+     * @return Condition
+     */
+    public static function lessThan($column, $value)
+    {
+        return new LessThan($column, $value);
+    }
+
+    /**
+     * Return whether the given rule's value is less than the given item's value
+     *
+     * @param LessThan $rule
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchLessThan(LessThan $rule, $row)
+    {
+        $rowValue = $this->extractValue($rule->getColumn(), $row);
+        if ($rowValue === null) {
+            return false;
+        }
+
+        return $rowValue < $rule->getValue();
+    }
+
+    /**
+     * Create a rule that matches rows with a column that is **greater** than or **equal** to the given value
+     *
+     * @param string $column
+     * @param float|int|string $value
+     *
+     * @return Condition
+     */
+    public static function greaterThanOrEqual($column, $value)
+    {
+        return new GreaterThanOrEqual($column, $value);
+    }
+
+    /**
+     * Return whether the given rule's value is greater than or equals the given item's value
+     *
+     * @param GreaterThanOrEqual $rule
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchGreaterThanOrEqual(GreaterThanOrEqual $rule, $row)
+    {
+        return $this->extractValue($rule->getColumn(), $row) >= $rule->getValue();
+    }
+
+    /**
+     * Create a rule that matches rows with a column that is **less** than or **equal** to the given value
+     *
+     * @param string $column
+     * @param float|int|string $value
+     *
+     * @return Condition
+     */
+    public static function lessThanOrEqual($column, $value)
+    {
+        return new LessThanOrEqual($column, $value);
+    }
+
+    /**
+     * Return whether the given rule's value is less than or equals the given item's value
+     *
+     * @param LessThanOrEqual $rule
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function matchLessThanOrEqual(LessThanOrEqual $rule, $row)
+    {
+        $rowValue = $this->extractValue($rule->getColumn(), $row);
+        if ($rowValue === null) {
+            return false;
+        }
+
+        return $rowValue <= $rule->getValue();
+    }
+
+    /**
+     * Perform the appropriate match for the given rule on the given item
+     *
+     * @param Rule $rule
+     * @param object $row
+     *
+     * @return bool
+     */
+    protected function performMatch(Rule $rule, $row)
+    {
+        switch (true) {
+            case $rule instanceof All:
+                return $this->matchAll($rule, $row);
+            case $rule instanceof Any:
+                return $this->matchAny($rule, $row);
+            case $rule instanceof Like:
+                return $this->matchSimilar($rule, $row);
+            case $rule instanceof Equal:
+                return $this->matchEqual($rule, $row);
+            case $rule instanceof GreaterThan:
+                return $this->matchGreaterThan($rule, $row);
+            case $rule instanceof GreaterThanOrEqual:
+                return $this->matchGreaterThanOrEqual($rule, $row);
+            case $rule instanceof LessThan:
+                return $this->matchLessThan($rule, $row);
+            case $rule instanceof LessThanOrEqual:
+                return $this->matchLessThanOrEqual($rule, $row);
+            case $rule instanceof None:
+                return $this->matchNone($rule, $row);
+            case $rule instanceof Unequal:
+                return $this->matchUnequal($rule, $row);
+            case $rule instanceof Unlike:
+                return $this->matchUnlike($rule, $row);
+            default:
+                throw new InvalidArgumentException(sprintf(
+                    'Unable to match filter. Rule type %s is unknown',
+                    get_class($rule)
+                ));
+        }
+    }
+
+    /**
+     * Return a value from the given row suitable to work with
+     *
+     * @param string $column
+     * @param object $row
+     *
+     * @return mixed
+     */
+    protected function extractValue($column, $row)
+    {
+        try {
+            return $row->{$column};
+        } catch (Exception $_) {
+            return null;
+        }
+    }
+
+    /**
+     * Normalize type of $value to the one of $rowValue
+     *
+     * For details on how this works please see the corresponding test
+     * {@see \ipl\Tests\Stdlib\FilterTest::testConditionsAreValueTypeAgnostic}
+     *
+     * @param mixed $rowValue
+     * @param mixed $value
+     *
+     * @return void
+     */
+    protected function normalizeTypes($rowValue, &$value)
+    {
+        if ($rowValue === null || $value === null) {
+            return;
+        }
+
+        if (is_array($rowValue)) {
+            if (empty($rowValue)) {
+                return;
+            }
+
+            $rowValue = array_shift($rowValue);
+        }
+
+        if (is_array($value)) {
+            if (is_bool($rowValue) && ! empty($value) && is_string(array_values($value)[0])) {
+                return;
+            }
+
+            $rowValueType = gettype($rowValue);
+            foreach ($value as &$val) {
+                settype($val, $rowValueType);
+            }
+        } elseif (! is_bool($rowValue) || ! is_string($value)) {
+            settype($value, gettype($rowValue));
+        }
+    }
+}
diff --git a/vendor/ipl/stdlib/src/Filter/All.php b/vendor/ipl/stdlib/src/Filter/All.php
new file mode 100644
index 0000000..67b47b6
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/All.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class All extends Chain
+{
+}
diff --git a/vendor/ipl/stdlib/src/Filter/Any.php b/vendor/ipl/stdlib/src/Filter/Any.php
new file mode 100644
index 0000000..5d47ebe
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/Any.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class Any extends Chain
+{
+}
diff --git a/vendor/ipl/stdlib/src/Filter/Chain.php b/vendor/ipl/stdlib/src/Filter/Chain.php
new file mode 100644
index 0000000..9422d3a
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/Chain.php
@@ -0,0 +1,179 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+use ArrayIterator;
+use Countable;
+use IteratorAggregate;
+use OutOfBoundsException;
+use Traversable;
+
+abstract class Chain implements Rule, MetaDataProvider, IteratorAggregate, Countable
+{
+    use MetaData;
+
+    /** @var array<int, Rule> */
+    protected $rules = [];
+
+    /**
+     * Create a new Chain
+     *
+     * @param Rule ...$rules
+     */
+    public function __construct(Rule ...$rules)
+    {
+        foreach ($rules as $rule) {
+            $this->add($rule);
+        }
+    }
+
+    /**
+     * Clone this chain's meta data and rules
+     */
+    public function __clone()
+    {
+        if ($this->metaData !== null) {
+            $this->metaData = clone $this->metaData;
+        }
+
+        foreach ($this->rules as $i => $rule) {
+            $this->rules[$i] = clone $rule;
+        }
+    }
+
+    /**
+     * Get an iterator this chain's rules
+     *
+     * @return ArrayIterator<int, Rule>
+     */
+    public function getIterator(): Traversable
+    {
+        return new ArrayIterator($this->rules);
+    }
+
+    /**
+     * Add a rule to this chain
+     *
+     * @param Rule $rule
+     *
+     * @return $this
+     */
+    public function add(Rule $rule)
+    {
+        $this->rules[] = $rule;
+
+        return $this;
+    }
+
+    /**
+     * Prepend a rule to an existing rule in this chain
+     *
+     * @param Rule $rule
+     * @param Rule $before
+     *
+     * @throws OutOfBoundsException In case no existing rule is found
+     * @return $this
+     */
+    public function insertBefore(Rule $rule, Rule $before)
+    {
+        $ruleAt = array_search($before, $this->rules, true);
+        if ($ruleAt === false) {
+            throw new OutOfBoundsException('Reference rule not found');
+        }
+
+        array_splice($this->rules, $ruleAt, 0, [$rule]);
+
+        return $this;
+    }
+
+    /**
+     * Append a rule to an existing rule in this chain
+     *
+     * @param Rule $rule
+     * @param Rule $after
+     *
+     * @throws OutOfBoundsException In case no existing rule is found
+     * @return $this
+     */
+    public function insertAfter(Rule $rule, Rule $after)
+    {
+        $ruleAt = array_search($after, $this->rules, true);
+        if ($ruleAt === false) {
+            throw new OutOfBoundsException('Reference rule not found');
+        }
+
+        array_splice($this->rules, $ruleAt + 1, 0, [$rule]);
+
+        return $this;
+    }
+
+    /**
+     * Get whether this chain contains the given rule
+     *
+     * @param Rule $rule
+     *
+     * @return bool
+     */
+    public function has(Rule $rule)
+    {
+        return array_search($rule, $this->rules, true) !== false;
+    }
+
+    /**
+     * Replace a rule with another one in this chain
+     *
+     * @param Rule $rule
+     * @param Rule $replacement
+     *
+     * @throws OutOfBoundsException In case no existing rule is found
+     * @return $this
+     */
+    public function replace(Rule $rule, Rule $replacement)
+    {
+        $ruleAt = array_search($rule, $this->rules, true);
+        if ($ruleAt === false) {
+            throw new OutOfBoundsException('Rule to replace not found');
+        }
+
+        array_splice($this->rules, $ruleAt, 1, [$replacement]);
+
+        return $this;
+    }
+
+    /**
+     * Remove a rule from this chain
+     *
+     * @param Rule $rule
+     *
+     * @return $this
+     */
+    public function remove(Rule $rule)
+    {
+        $ruleAt = array_search($rule, $this->rules, true);
+        if ($ruleAt !== false) {
+            array_splice($this->rules, $ruleAt, 1, []);
+        }
+
+        return $this;
+    }
+
+    /**
+     * Get whether this chain has any rules
+     *
+     * @return bool
+     */
+    public function isEmpty()
+    {
+        return empty($this->rules);
+    }
+
+    /**
+     * Count this chain's rules
+     *
+     * @return int
+     */
+    public function count(): int
+    {
+        return count($this->rules);
+    }
+}
diff --git a/vendor/ipl/stdlib/src/Filter/Condition.php b/vendor/ipl/stdlib/src/Filter/Condition.php
new file mode 100644
index 0000000..cc35610
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/Condition.php
@@ -0,0 +1,84 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+abstract class Condition implements Rule, MetaDataProvider
+{
+    use MetaData;
+
+    /** @var string */
+    protected $column;
+
+    /** @var mixed */
+    protected $value;
+
+    /**
+     * Create a new Condition
+     *
+     * @param string $column
+     * @param mixed $value
+     */
+    public function __construct($column, $value)
+    {
+        $this->setColumn($column)
+            ->setValue($value);
+    }
+
+    /**
+     * Clone this condition's meta data
+     */
+    public function __clone()
+    {
+        if ($this->metaData !== null) {
+            $this->metaData = clone $this->metaData;
+        }
+    }
+
+    /**
+     * Set this condition's column
+     *
+     * @param string $column
+     *
+     * @return $this
+     */
+    public function setColumn($column)
+    {
+        $this->column = $column;
+
+        return $this;
+    }
+
+    /**
+     * Get this condition's column
+     *
+     * @return string
+     */
+    public function getColumn()
+    {
+        return $this->column;
+    }
+
+    /**
+     * Set this condition's value
+     *
+     * @param mixed $value
+     *
+     * @return $this
+     */
+    public function setValue($value)
+    {
+        $this->value = $value;
+
+        return $this;
+    }
+
+    /**
+     * Get this condition's value
+     *
+     * @return mixed
+     */
+    public function getValue()
+    {
+        return $this->value;
+    }
+}
diff --git a/vendor/ipl/stdlib/src/Filter/Equal.php b/vendor/ipl/stdlib/src/Filter/Equal.php
new file mode 100644
index 0000000..71da490
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/Equal.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class Equal extends Condition
+{
+    /** @var bool */
+    protected $ignoreCase = false;
+
+    /**
+     * Ignore case on both sides of the equation
+     *
+     * @return $this
+     */
+    public function ignoreCase()
+    {
+        $this->ignoreCase = true;
+
+        return $this;
+    }
+
+    /**
+    * Return whether this rule ignores case
+    *
+    * @return bool
+    */
+    public function ignoresCase()
+    {
+        return $this->ignoreCase;
+    }
+}
diff --git a/vendor/ipl/stdlib/src/Filter/GreaterThan.php b/vendor/ipl/stdlib/src/Filter/GreaterThan.php
new file mode 100644
index 0000000..fd8190c
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/GreaterThan.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class GreaterThan extends Condition
+{
+}
diff --git a/vendor/ipl/stdlib/src/Filter/GreaterThanOrEqual.php b/vendor/ipl/stdlib/src/Filter/GreaterThanOrEqual.php
new file mode 100644
index 0000000..4cd4a73
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/GreaterThanOrEqual.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class GreaterThanOrEqual extends Condition
+{
+}
diff --git a/vendor/ipl/stdlib/src/Filter/LessThan.php b/vendor/ipl/stdlib/src/Filter/LessThan.php
new file mode 100644
index 0000000..297493f
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/LessThan.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class LessThan extends Condition
+{
+}
diff --git a/vendor/ipl/stdlib/src/Filter/LessThanOrEqual.php b/vendor/ipl/stdlib/src/Filter/LessThanOrEqual.php
new file mode 100644
index 0000000..ef35974
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/LessThanOrEqual.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class LessThanOrEqual extends Condition
+{
+}
diff --git a/vendor/ipl/stdlib/src/Filter/Like.php b/vendor/ipl/stdlib/src/Filter/Like.php
new file mode 100644
index 0000000..7a06279
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/Like.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class Like extends Condition
+{
+    /** @var bool */
+    protected $ignoreCase = false;
+
+    /**
+     * Ignore case on both sides of the equation
+     *
+     * @return $this
+     */
+    public function ignoreCase()
+    {
+        $this->ignoreCase = true;
+
+        return $this;
+    }
+
+    /**
+    * Return whether this rule ignores case
+    *
+    * @return bool
+    */
+    public function ignoresCase()
+    {
+        return $this->ignoreCase;
+    }
+}
diff --git a/vendor/ipl/stdlib/src/Filter/MetaData.php b/vendor/ipl/stdlib/src/Filter/MetaData.php
new file mode 100644
index 0000000..6fe2523
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/MetaData.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+use ipl\Stdlib\Data;
+
+trait MetaData
+{
+    /** @var Data */
+    protected $metaData;
+
+    public function metaData()
+    {
+        if ($this->metaData === null) {
+            $this->metaData = new Data();
+        }
+
+        return $this->metaData;
+    }
+}
diff --git a/vendor/ipl/stdlib/src/Filter/MetaDataProvider.php b/vendor/ipl/stdlib/src/Filter/MetaDataProvider.php
new file mode 100644
index 0000000..ef9557e
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/MetaDataProvider.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+use ipl\Stdlib\Data;
+
+interface MetaDataProvider
+{
+    /**
+     * Get this rule's meta data
+     *
+     * @return Data
+     */
+    public function metaData();
+}
diff --git a/vendor/ipl/stdlib/src/Filter/None.php b/vendor/ipl/stdlib/src/Filter/None.php
new file mode 100644
index 0000000..a1b14f7
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/None.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class None extends Chain
+{
+}
diff --git a/vendor/ipl/stdlib/src/Filter/Rule.php b/vendor/ipl/stdlib/src/Filter/Rule.php
new file mode 100644
index 0000000..dc83c80
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/Rule.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+interface Rule
+{
+}
diff --git a/vendor/ipl/stdlib/src/Filter/Unequal.php b/vendor/ipl/stdlib/src/Filter/Unequal.php
new file mode 100644
index 0000000..5e37cbd
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/Unequal.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class Unequal extends Condition
+{
+    /** @var bool */
+    protected $ignoreCase = false;
+
+    /**
+     * Ignore case on both sides of the equation
+     *
+     * @return $this
+     */
+    public function ignoreCase()
+    {
+        $this->ignoreCase = true;
+
+        return $this;
+    }
+
+    /**
+    * Return whether this rule ignores case
+    *
+    * @return bool
+    */
+    public function ignoresCase()
+    {
+        return $this->ignoreCase;
+    }
+}
diff --git a/vendor/ipl/stdlib/src/Filter/Unlike.php b/vendor/ipl/stdlib/src/Filter/Unlike.php
new file mode 100644
index 0000000..16b9fb3
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filter/Unlike.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace ipl\Stdlib\Filter;
+
+class Unlike extends Condition
+{
+    /** @var bool */
+    protected $ignoreCase = false;
+
+    /**
+     * Ignore case on both sides of the equation
+     *
+     * @return $this
+     */
+    public function ignoreCase()
+    {
+        $this->ignoreCase = true;
+
+        return $this;
+    }
+
+    /**
+    * Return whether this rule ignores case
+    *
+    * @return bool
+    */
+    public function ignoresCase()
+    {
+        return $this->ignoreCase;
+    }
+}
diff --git a/vendor/ipl/stdlib/src/Filters.php b/vendor/ipl/stdlib/src/Filters.php
new file mode 100644
index 0000000..defff43
--- /dev/null
+++ b/vendor/ipl/stdlib/src/Filters.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace ipl\Stdlib;
+
+trait Filters
+{
+    /** @var Filter\Chain */
+    protected $filter;
+
+    public function getFilter()
+    {
+        return $this->filter ?: Filter::all();
+    }
+
+    public function filter(Filter\Rule $filter)
+    {
+        $currentFilter = $this->getFilter();
+        if ($currentFilter instanceof Filter\All) {
+            $this->filter = $currentFilter->add($filter);
+        } else {
+            $this->filter = Filter::all($filter);
+            if (! $currentFilter->isEmpty()) {
+                $this->filter->insertBefore($currentFilter, $filter);
+            }
+        }
+
+        return $this;
+    }
+
+    public function orFilter(Filter\Rule $filter)
+    {
+        $currentFilter = $this->getFilter();
+        if ($currentFilter instanceof Filter\Any) {
+            $this->filter = $currentFilter->add($filter);
+        } else {
+            $this->filter = Filter::any($filter);
+            if (! $currentFilter->isEmpty()) {
+                $this->filter->insertBefore($currentFilter, $filter);
+            }
+        }
+
+        return $this;
+    }
+
+    public function notFilter(Filter\Rule $filter)
+    {
+        $this->filter(Filter::none($filter));
+
+        return $this;
+    }
+
+    public function orNotFilter(Filter\Rule $filter)
+    {
+        $this->orFilter(Filter::none($filter));
+
+        return $this;
+    }
+}