├── .gitignore
├── src
    └── chainy
    │   ├── Keys.php
    │   ├── LowerCase.php
    │   ├── UpperCase.php
    │   ├── Values.php
    │   ├── Reverse.php
    │   ├── Trim.php
    │   ├── Ltrim.php
    │   ├── Rtrim.php
    │   ├── StripLow.php
    │   ├── Ucfirst.php
    │   ├── StripHigh.php
    │   ├── Capitalize.php
    │   ├── BaseTrim.php
    │   ├── Join.php
    │   ├── Split.php
    │   ├── StripTags.php
    │   ├── Unique.php
    │   ├── Ksort.php
    │   ├── Sort.php
    │   ├── Column.php
    │   ├── CombineWithKeys.php
    │   ├── Map.php
    │   ├── CombineWithValues.php
    │   ├── Usort.php
    │   ├── Uksort.php
    │   ├── Substr.php
    │   ├── Merge.php
    │   ├── Each.php
    │   ├── Xargs.php
    │   ├── StrReplace.php
    │   ├── Reduce.php
    │   ├── MapKeyValue.php
    │   ├── Filter.php
    │   ├── Slice.php
    │   ├── Splice.php
    │   ├── ReduceKeyValue.php
    │   └── Chain.php
├── .travis.yml
├── test
    ├── MapTest.php
    ├── JoinTest.php
    ├── SplitTest.php
    ├── SortTest.php
    ├── UniqueTest.php
    ├── ReverseTest.php
    ├── KeysTest.php
    ├── ValuesTest.php
    ├── KsortTest.php
    ├── UsortTest.php
    ├── UksortTest.php
    ├── MergeTest.php
    ├── ColumnTest.php
    ├── MapKeyValueTest.php
    ├── CombineWithKeysTest.php
    ├── CombineWithValuesTest.php
    ├── XargsTest.php
    ├── SpliceTest.php
    ├── TrimTest.php
    ├── UcfirstTest.php
    ├── RtrimTest.php
    ├── CapitalizeTest.php
    ├── LowerCaseTest.php
    ├── LtrimTest.php
    ├── UpperCaseTest.php
    ├── EachTest.php
    ├── StripLowTest.php
    ├── StripHighTest.php
    ├── StrReplaceTest.php
    ├── SubstrTest.php
    ├── ReduceTest.php
    ├── StripTagsTest.php
    ├── ReduceKeyValueTest.php
    ├── ChainTest.php
    ├── SliceTest.php
    └── FilterTest.php
├── composer.json
├── phpunit.xml
├── README.md
└── composer.lock


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea
2 | vendor


--------------------------------------------------------------------------------
/src/chainy/Keys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Keys
 6 | {
 7 |     public function __invoke(array $value)
 8 |     {
 9 |         return array_keys($value);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/LowerCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class LowerCase
 6 | {
 7 |     function __invoke($value)
 8 |     {
 9 |         return mb_strtolower($value);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/UpperCase.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class UpperCase
 6 | {
 7 |     function __invoke($value)
 8 |     {
 9 |         return mb_strtoupper($value);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/Values.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Values
 6 | {
 7 |     public function __invoke(array $value)
 8 |     {
 9 |         return array_values($value);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/Reverse.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Reverse
 6 | {
 7 |     public function __invoke(array $value)
 8 |     {
 9 |         return array_reverse($value);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/Trim.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Trim extends BaseTrim
 6 | {
 7 |     public function __invoke(string $value)
 8 |     {
 9 |         return trim($value, $this->chars);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/Ltrim.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Ltrim extends BaseTrim
 6 | {
 7 |     public function __invoke(string $value)
 8 |     {
 9 |         return ltrim($value, $this->chars);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/Rtrim.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Rtrim extends BaseTrim
 6 | {
 7 |     public function __invoke(string $value)
 8 |     {
 9 |         return rtrim($value, $this->chars);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/StripLow.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class StripLow
 6 | {
 7 |     public function __invoke(string $value)
 8 |     {
 9 |         return preg_replace("/[\x{0}-\x{1f}]/", "", $value);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/Ucfirst.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Ucfirst
 6 | {
 7 |     function __invoke($value)
 8 |     {
 9 |         return mb_strtoupper(mb_substr($value, 0, 1)) . mb_substr($value, 1);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/src/chainy/StripHigh.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class StripHigh
 6 | {
 7 |     public function __invoke(string $value)
 8 |     {
 9 |         return preg_replace("/[\x{80}-\x{ff}]/", "", $value);
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - 7.0
 5 |   - 7.1
 6 |   - 7.2
 7 | 
 8 | cache:
 9 |   directories:
10 |     - $HOME/.composer/cache
11 | 
12 | install:
13 |   - composer install
14 | 
15 | script:
16 |   - php vendor/bin/phpunit
17 | 


--------------------------------------------------------------------------------
/src/chainy/Capitalize.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Capitalize
 6 | {
 7 |     function __invoke($value)
 8 |     {
 9 |         return mb_strtoupper(mb_substr($value, 0, 1)) . mb_strtolower(mb_substr($value, 1));
10 |     }
11 | }
12 | 


--------------------------------------------------------------------------------
/test/MapTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Map;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class MapTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $this->assertEquals(["LOWER"], (new Map("strtoupper"))(["lower"]));
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/src/chainy/BaseTrim.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class BaseTrim
 6 | {
 7 |     const DEFAULT_CHARLIST = "\t\n\r \v";
 8 |     protected $chars;
 9 | 
10 |     public function __construct($chars = null)
11 |     {
12 |         $this->chars = $chars ?? self::DEFAULT_CHARLIST;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/test/JoinTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Join;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class JoinTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $this->assertEquals("hello world", (new Join(" "))(["hello", "world"]));
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/test/SplitTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Split;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class SplitTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $this->assertEquals(["hello", "world"], (new Split(" "))("hello world"));
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/test/SortTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Sort;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class SortTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $in = [3, 2, 4, 1];
13 |         $this->assertEquals([1, 2, 3, 4], (new Sort)($in));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/test/UniqueTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Unique;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class UniqueTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $this->assertEquals([1, 2, 3, 4], (new Unique())([1, 2, 3, 4, 1, 2, 3, 4]));
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/test/ReverseTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Reverse;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ReverseTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $in = [1, 2, 3, 4];
13 |         $this->assertEquals([4, 3, 2, 1], (new Reverse)($in));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/chainy/Join.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Join
 6 | {
 7 |     private $glue;
 8 |     public function __construct(string $glue = "")
 9 |     {
10 |         $this->glue = $glue;
11 |     }
12 | 
13 |     public function __invoke(array $value)
14 |     {
15 |         return join($this->glue, $value);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/test/KeysTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Keys;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class KeysTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $in = ["key1" => "val1", "key2" => "val2"];
13 |         $this->assertEquals(["key1", "key2"], (new Keys)($in));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/test/ValuesTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Values;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ValuesTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $in = ["key1" => "val1", "key2" => "val2"];
13 |         $this->assertEquals(["val1", "val2"], (new Values)($in));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/chainy/Split.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Split
 6 | {
 7 |     private $delimiter;
 8 |     public function __construct(string $delimiter)
 9 |     {
10 |         $this->delimiter = $delimiter;
11 |     }
12 | 
13 |     public function __invoke(string $value)
14 |     {
15 |         return explode($this->delimiter, $value);
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/test/KsortTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Ksort;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class KsortTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $in = [3 => 1, 2 => 1, 4 => 1, 1 => 1];
13 |         $this->assertEquals([1 => 1, 2 => 1, 3 => 1, 4 => 1], (new Ksort)($in));
14 |     }
15 | }
16 | 


--------------------------------------------------------------------------------
/src/chainy/StripTags.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class StripTags
 6 | {
 7 |     protected $allowed;
 8 | 
 9 |     public function __construct($allowed = null)
10 |     {
11 |         $this->allowed = $allowed;
12 |     }
13 | 
14 |     public function __invoke(string $value)
15 |     {
16 |         return strip_tags($value, $this->allowed);
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "crocodile2u/chainy",
 3 |   "autoload": {
 4 |     "psr-4" : {
 5 |       "chainy\\" : "./src/chainy"
 6 |     }
 7 |   },
 8 |   "autoload-dev": {
 9 |       "psr-4": {
10 |           "chainy\\test\\": "./test"
11 |       }
12 |   },
13 |   "require": {
14 |     "php": ">=7.0",
15 |     "ext-mbstring": "*"
16 |   },
17 |   "require-dev": {
18 |       "phpunit/phpunit": "^6.5"
19 |   }
20 | }
21 | 


--------------------------------------------------------------------------------
/test/UsortTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Usort;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class UsortTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $in = [3, 2, 4, 1];
13 |         $sorter = new Usort(function($a, $b) {
14 |             return -($a <=> $b);
15 |         });
16 |         $this->assertEquals([4, 3, 2, 1], $sorter($in));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/chainy/Unique.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Unique
 6 | {
 7 |     private $sortFlags;
 8 |     /**
 9 |      * Unique constructor.
10 |      * @param int $sortFlags
11 |      */
12 |     public function __construct($sortFlags = SORT_STRING)
13 |     {
14 |         $this->sortFlags = $sortFlags;
15 |     }
16 | 
17 |     public function __invoke(array $value)
18 |     {
19 |         return array_unique($value, $this->sortFlags);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/test/UksortTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Uksort;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class UksortTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $in = [3 => 1, 2 => 1, 4 => 1, 1 => 1];
13 |         $sorter = new Uksort(function($a, $b) {
14 |             return -($a <=> $b);
15 |         });
16 |         $this->assertEquals([4 => 1, 3 => 1, 2 => 1, 1 => 1], $sorter($in));
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/src/chainy/Ksort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Ksort
 6 | {
 7 |     private $sortFlags;
 8 |     /**
 9 |      * Unique constructor.
10 |      * @param int $sortFlags
11 |      */
12 |     public function __construct($sortFlags = SORT_STRING)
13 |     {
14 |         $this->sortFlags = $sortFlags;
15 |     }
16 | 
17 |     public function __invoke(array $value)
18 |     {
19 |         ksort($value, $this->sortFlags);
20 |         return $value;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/chainy/Sort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Sort
 6 | {
 7 |     private $sortFlags;
 8 |     /**
 9 |      * Unique constructor.
10 |      * @param int $sortFlags
11 |      */
12 |     public function __construct($sortFlags = SORT_STRING)
13 |     {
14 |         $this->sortFlags = $sortFlags;
15 |     }
16 | 
17 |     public function __invoke(array $value)
18 |     {
19 |         sort($value, $this->sortFlags);
20 |         return $value;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/chainy/Column.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Column
 6 | {
 7 |     /**
 8 |      * @var mixed
 9 |      */
10 |     private $column;
11 | 
12 |     /**
13 |      * Column constructor.
14 |      * @param mixed $column
15 |      */
16 |     public function __construct($column)
17 |     {
18 |         $this->column = $column;
19 |     }
20 | 
21 |     public function __invoke(array $value)
22 |     {
23 |         return array_column($value, $this->column);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/MergeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Merge;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class MergeTest extends TestCase
 9 | {
10 |     function testCallbackIsCalledOnEveryElementWithCorrectArgs()
11 |     {
12 |         $in = [1];
13 |         $arg1 = [2];
14 |         $this->assertEquals([1, 2], (new Merge($arg1))($in));
15 | 
16 | 
17 |         $arg2 = [3];
18 |         $this->assertEquals([1, 2, 3], (new Merge($arg1, $arg2))($in));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/chainy/CombineWithKeys.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class CombineWithKeys
 6 | {
 7 |     /**
 8 |      * @var array
 9 |      */
10 |     private $keys;
11 | 
12 |     /**
13 |      * Map constructor.
14 |      * @param array $keys
15 |      */
16 |     public function __construct(array $keys)
17 |     {
18 |         $this->keys = $keys;
19 |     }
20 | 
21 |     public function __invoke(array $values)
22 |     {
23 |         return array_combine($this->keys, $values);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/ColumnTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Column;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ColumnTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $data = [
13 |             ["id" => 1, "name" => "n1"],
14 |             ["id" => 2, "name" => "n2"],
15 |         ];
16 |         $this->assertEquals([1, 2], (new Column("id"))($data));
17 |         $this->assertEquals(["n1", "n2"], (new Column("name"))($data));
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/test/MapKeyValueTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Map;
 6 | use chainy\MapKeyValue;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class MapKeyValueTest extends TestCase
10 | {
11 |     function testInvoke()
12 |     {
13 |         $input = ["key" => "val"];
14 |         $transform = function($value, $key) {
15 |             return "$key:$value";
16 |         };
17 |         $this->assertEquals(["key" => "key:val"], (new MapKeyValue($transform))($input));
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/chainy/Map.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Map
 6 | {
 7 |     /**
 8 |      * @var callable
 9 |      */
10 |     private $callback;
11 | 
12 |     /**
13 |      * Map constructor.
14 |      * @param callable $callback
15 |      */
16 |     public function __construct(callable $callback)
17 |     {
18 |         $this->callback = $callback;
19 |     }
20 | 
21 |     public function __invoke(array $value)
22 |     {
23 |         return array_map($this->callback, $value);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/chainy/CombineWithValues.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class CombineWithValues
 6 | {
 7 |     /**
 8 |      * @var array
 9 |      */
10 |     private $values;
11 | 
12 |     /**
13 |      * Map constructor.
14 |      * @param array $keys
15 |      */
16 |     public function __construct(array $values)
17 |     {
18 |         $this->values = $values;
19 |     }
20 | 
21 |     public function __invoke(array $keys)
22 |     {
23 |         return array_combine($keys, $this->values);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/CombineWithKeysTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\CombineWithKeys;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class CombineWithKeysTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $keys = ["k1", "k2"];
13 |         $values = ["v1", "v2"];
14 |         $combined = [
15 |             "k1" => "v1",
16 |             "k2" => "v2",
17 |         ];
18 |         $this->assertEquals($combined, (new CombineWithKeys($keys))($values));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/test/CombineWithValuesTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\CombineWithValues;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class CombineWithValuesTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $keys = ["k1", "k2"];
13 |         $values = ["v1", "v2"];
14 |         $combined = [
15 |             "k1" => "v1",
16 |             "k2" => "v2",
17 |         ];
18 |         $this->assertEquals($combined, (new CombineWithValues($values))($keys));
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/chainy/Usort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Usort
 6 | {
 7 |     /**
 8 |      * @var callable|null
 9 |      */
10 |     private $callback;
11 | 
12 |     /**
13 |      * Filter constructor.
14 |      * @param callable $callback
15 |      */
16 |     public function __construct($callback = null)
17 |     {
18 |         $this->callback = $callback;
19 |     }
20 | 
21 |     public function __invoke(array $value)
22 |     {
23 |         usort($value, $this->callback);
24 |         return $value;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/chainy/Uksort.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Uksort
 6 | {
 7 |     /**
 8 |      * @var callable|null
 9 |      */
10 |     private $callback;
11 | 
12 |     /**
13 |      * Filter constructor.
14 |      * @param callable $callback
15 |      */
16 |     public function __construct($callback = null)
17 |     {
18 |         $this->callback = $callback;
19 |     }
20 | 
21 |     public function __invoke(array $value)
22 |     {
23 |         uksort($value, $this->callback);
24 |         return $value;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit bootstrap="vendor/autoload.php" colors="true" backupGlobals="false"
 3 |          backupStaticAttributes="false" syntaxCheck="false">
 4 |     <testsuites>
 5 |         <testsuite name="Tests">
 6 |             <directory suffix="Test.php">test</directory>
 7 |         </testsuite>
 8 |     </testsuites>
 9 |     <filter>
10 |         <whitelist processUncoveredFilesFromWhitelist="false">
11 |             <directory suffix=".php">src</directory>
12 |         </whitelist>
13 |     </filter>
14 | </phpunit>
15 | 


--------------------------------------------------------------------------------
/src/chainy/Substr.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Substr
 6 | {
 7 |     /**
 8 |      * @var int
 9 |      */
10 |     private $start, $length;
11 | 
12 |     /**
13 |      * Substr constructor.
14 |      * @param int $start
15 |      * @param int $length
16 |      */
17 |     public function __construct(int $start, $length = null)
18 |     {
19 |         $this->start = $start;
20 |         $this->length = $length;
21 |     }
22 | 
23 |     function __invoke($value)
24 |     {
25 |         return mb_substr($value, $this->start, $this->length);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/chainy/Merge.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Merge
 6 | {
 7 |     /**
 8 |      * @var array[]
 9 |      */
10 |     private $args;
11 | 
12 |     /**
13 |      * Map constructor.
14 |      * @param array[] $args
15 |      */
16 |     public function __construct(array ...$args)
17 |     {
18 |         $this->args = $args;
19 |     }
20 | 
21 |     public function __invoke(array $value)
22 |     {
23 |         $callArgs = $this->args;
24 |         array_unshift($callArgs, $value);
25 |         return call_user_func_array("array_merge", $callArgs);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/chainy/Each.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Each
 6 | {
 7 |     /**
 8 |      * @var callable
 9 |      */
10 |     private $callback;
11 | 
12 |     /**
13 |      * Map constructor.
14 |      * @param callable $callback
15 |      */
16 |     public function __construct(callable $callback)
17 |     {
18 |         $this->callback = $callback;
19 |     }
20 | 
21 |     public function __invoke(array $value)
22 |     {
23 |         foreach ($value as $key => $item) {
24 |             call_user_func_array($this->callback, [$item, $key]);
25 |         }
26 |         return $value;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/chainy/Xargs.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Xargs
 6 | {
 7 |     /**
 8 |      * @var callable
 9 |      */
10 |     private $callback;
11 | 
12 |     /**
13 |      * Xargs constructor.
14 |      * @param callable $callback
15 |      */
16 |     function __construct(callable $callback)
17 |     {
18 |         $this->callback = $callback;
19 |     }
20 | 
21 |     function __invoke($args)
22 |     {
23 |         if (null === $args) {
24 |             $args = [null];
25 |         } else {
26 |             $args = (array) $args;
27 |         }
28 |         return ($this->callback)(...$args);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/XargsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Xargs;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class XargsTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $f = function ($arg1, $arg2, $arg3) {
13 |             return $arg1 . $arg2 . $arg3;
14 |         };
15 |         $this->assertEquals("hello world", (new Xargs($f))(["hello", " ", "world"]));
16 |     }
17 | 
18 |     function testInvokeOnNullArg()
19 |     {
20 |         $f = function ($arg1) {
21 |             return null;
22 |         };
23 |         $this->assertNull((new Xargs($f))(null));
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/test/SpliceTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Splice;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class SpliceTest extends TestCase
 9 | {
10 |     function testNoReplacement()
11 |     {
12 |         $arr = [1, 2, 3];
13 |         $this->assertEquals([2, 3], (new Splice(1, 2))($arr));
14 |         $this->assertEquals([1], $arr);
15 |     }
16 | 
17 |     function testReplacement()
18 |     {
19 |         $arr = [1, 2, 3];
20 |         $replacement = [10];
21 |         $this->assertEquals([2, 3], (new Splice(1, 2, $replacement))($arr));
22 |         $this->assertEquals([1, 10], $arr);
23 |     }
24 | 
25 | }
26 | 


--------------------------------------------------------------------------------
/src/chainy/StrReplace.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class StrReplace
 6 | {
 7 |     /**
 8 |      * @var string|array
 9 |      */
10 |     private $search, $replacement;
11 | 
12 |     /**
13 |      * Replace constructor.
14 |      * @param string|array $search
15 |      * @param string|array $replacement
16 |      */
17 |     public function __construct($search, $replacement)
18 |     {
19 |         $this->search = $search;
20 |         $this->replacement = $replacement;
21 |     }
22 | 
23 |     public function __invoke($target)
24 |     {
25 |         return str_replace($this->search, $this->replacement, $target);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/test/TrimTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Trim;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class TrimTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $str
12 |      * @param $chars
13 |      * @param $expected
14 |      * @dataProvider provider_testInvoke
15 |      */
16 |     function testInvoke($str, $chars, $expected)
17 |     {
18 |         $this->assertEquals($expected, (new Trim($chars))($str));
19 |     }
20 | 
21 |     function provider_testInvoke()
22 |     {
23 |         return [
24 |             [" str ", null, "str"],
25 |             ["/.str/...", "/.", "str"],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/UcfirstTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Ucfirst;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class UcfirstTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $input
12 |      * @param $expected
13 |      * @dataProvider provider_testInvoke
14 |      */
15 |     function testInvoke($input, $expected)
16 |     {
17 |         $this->assertEquals($expected, (new Ucfirst)($input));
18 |     }
19 | 
20 |     function provider_testInvoke()
21 |     {
22 |         return [
23 |             ["lower", "Lower"],
24 |             ["UPPER", "UPPER"],
25 |             ["mIxEd", "MIxEd"],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/RtrimTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Rtrim;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class RtrimTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $str
12 |      * @param $chars
13 |      * @param $expected
14 |      * @dataProvider provider_testInvoke
15 |      */
16 |     function testInvoke($str, $chars, $expected)
17 |     {
18 |         $this->assertEquals($expected, (new Rtrim($chars))($str));
19 |     }
20 | 
21 |     function provider_testInvoke()
22 |     {
23 |         return [
24 |             [" str ", null, " str"],
25 |             ["/.str/...", "/.", "/.str"],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/CapitalizeTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Capitalize;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class CapitalizeTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $input
12 |      * @param $expected
13 |      * @dataProvider provider_testInvoke
14 |      */
15 |     function testInvoke($input, $expected)
16 |     {
17 |         $this->assertEquals($expected, (new Capitalize)($input));
18 |     }
19 | 
20 |     function provider_testInvoke()
21 |     {
22 |         return [
23 |             ["lower", "Lower"],
24 |             ["UPPER", "Upper"],
25 |             ["mIxEd", "Mixed"],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/LowerCaseTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\LowerCase;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class LowerCaseTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $input
12 |      * @param $expected
13 |      * @dataProvider provider_testInvoke
14 |      */
15 |     function testInvoke($input, $expected)
16 |     {
17 |         $this->assertEquals($expected, (new LowerCase)($input));
18 |     }
19 | 
20 |     function provider_testInvoke()
21 |     {
22 |         return [
23 |             ["lower", "lower"],
24 |             ["UPPER", "upper"],
25 |             ["mIxEd", "mixed"],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/LtrimTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Ltrim;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class LtrimTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $str
12 |      * @param $chars
13 |      * @param $expected
14 |      * @dataProvider provider_testInvoke
15 |      */
16 |     function testInvoke($str, $chars, $expected)
17 |     {
18 |         $this->assertEquals($expected, (new Ltrim($chars))($str));
19 |     }
20 | 
21 |     function provider_testInvoke()
22 |     {
23 |         return [
24 |             [" str ", null, "str "],
25 |             ["/.str/...", "/.", "str/..."],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/UpperCaseTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\UpperCase;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class UpperCaseTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $input
12 |      * @param $expected
13 |      * @dataProvider provider_testInvoke
14 |      */
15 |     function testInvoke($input, $expected)
16 |     {
17 |         $this->assertEquals($expected, (new UpperCase)($input));
18 |     }
19 | 
20 |     function provider_testInvoke()
21 |     {
22 |         return [
23 |             ["lower", "LOWER"],
24 |             ["UPPER", "UPPER"],
25 |             ["mIxEd", "MIXED"],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/EachTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Each;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class EachTest extends TestCase
 9 | {
10 |     function testCallbackIsCalledOnEveryElementWithCorrectArgs()
11 |     {
12 |         $calls = [];
13 |         $f = function() use (&$calls) {
14 |             $calls[] = func_get_args();
15 |         };
16 |         $in = ["key1" => "val1", "key2" => "val2"];
17 |         $this->assertEquals($in, (new Each($f))($in));
18 |         $this->assertCount(count($in), $calls);
19 |         $this->assertEquals(["val1", "key1"], $calls[0]);
20 |         $this->assertEquals(["val2", "key2"], $calls[1]);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/chainy/Reduce.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Reduce
 6 | {
 7 |     /**
 8 |      * @var callable
 9 |      */
10 |     private $callback;
11 |     /**
12 |      * @var mixed
13 |      */
14 |     private $initial;
15 | 
16 |     /**
17 |      * Map constructor.
18 |      * @param callable $callback
19 |      * @param mixed $initial
20 |      */
21 |     public function __construct(callable $callback, $initial = null)
22 |     {
23 |         $this->callback = $callback;
24 |         $this->initial = $initial;
25 |     }
26 | 
27 |     public function __invoke(array $value)
28 |     {
29 |         return array_reduce($value, $this->callback, $this->initial);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/chainy/MapKeyValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class MapKeyValue
 6 | {
 7 |     /**
 8 |      * @var callable
 9 |      */
10 |     private $callback;
11 | 
12 |     /**
13 |      * MapKeyValue constructor.
14 |      * @param callable $callback function($value, $key) {...}
15 |      */
16 |     public function __construct(callable $callback)
17 |     {
18 |         $this->callback = $callback;
19 |     }
20 | 
21 |     public function __invoke(array $input)
22 |     {
23 |         $retval = [];
24 |         foreach ($input as $key => $val) {
25 |             $retval[$key] = call_user_func($this->callback, $val, $key);
26 |         }
27 |         return $retval;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/test/StripLowTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\StripLow;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class StripLowTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $input
12 |      * @param $expected
13 |      * @dataProvider provider_testInvoke
14 |      */
15 |     function testInvoke($input, $expected)
16 |     {
17 |         $this->assertEquals($expected, (new StripLow)($input));
18 |     }
19 | 
20 |     function provider_testInvoke()
21 |     {
22 |         return [
23 |             ["normal string", "normal string"],
24 |             ["\x1", ""],
25 |             ["some \x1 string with strange characters", "some  string with strange characters"],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/StripHighTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\StripHigh;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class StripHighTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $input
12 |      * @param $expected
13 |      * @dataProvider provider_testInvoke
14 |      */
15 |     function testInvoke($input, $expected)
16 |     {
17 |         $this->assertEquals($expected, (new StripHigh)($input));
18 |     }
19 | 
20 |     function provider_testInvoke()
21 |     {
22 |         return [
23 |             ["normal string", "normal string"],
24 |             ["\x1", "\x1"],
25 |             ["some \xA0 string with strange characters", "some  string with strange characters"],
26 |         ];
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/test/StrReplaceTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\StrReplace;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class StrReplaceTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $str
12 |      * @param $search
13 |      * @param $replacement
14 |      * @dataProvider provider_testInvoke
15 |      */
16 |     function testInvoke($str, $search, $replacement, $expected)
17 |     {
18 |         $this->assertEquals($expected, (new StrReplace($search, $replacement))($str));
19 |     }
20 | 
21 |     function provider_testInvoke()
22 |     {
23 |         return [
24 |             ["Hillary has won US presidential elections", "Hillary", "Trump", "Trump has won US presidential elections"],
25 |         ];
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/chainy/Filter.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Filter
 6 | {
 7 |     const FLAG_DEFAULT = 0;
 8 |     /**
 9 |      * @var callable|null
10 |      */
11 |     private $callback;
12 |     /**
13 |      * @var integer|null
14 |      */
15 |     private $flag;
16 | 
17 |     /**
18 |      * Filter constructor.
19 |      * @param callable $callback
20 |      * @param integer $flag
21 |      */
22 |     public function __construct($callback = null, $flag = self::FLAG_DEFAULT)
23 |     {
24 |         $this->callback = $callback;
25 |         $this->flag = $flag;
26 |     }
27 | 
28 |     public function __invoke(array $value)
29 |     {
30 |         return $this->callback ? array_filter($value, $this->callback, $this->flag) : array_filter($value);
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/chainy/Slice.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Slice
 6 | {
 7 |     /**
 8 |      * @var int
 9 |      */
10 |     private $offset;
11 | 
12 |     /**
13 |      * @var int
14 |      */
15 |     private $length;
16 |     /**
17 |      * @var bool
18 |      */
19 |     private $preserveKeys;
20 | 
21 |     /**
22 |      * Map constructor.
23 |      * @param int $offset
24 |      */
25 |     public function __construct($offset, $length = null, $preserveKeys = null)
26 |     {
27 |         $this->offset = $offset;
28 |         $this->length = $length;
29 |         $this->preserveKeys = $preserveKeys;
30 |     }
31 | 
32 |     public function __invoke(array $value)
33 |     {
34 |         return array_slice($value, $this->offset, $this->length, $this->preserveKeys);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/chainy/Splice.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class Splice
 6 | {
 7 |     /**
 8 |      * @var int
 9 |      */
10 |     private $offset;
11 | 
12 |     /**
13 |      * @var int
14 |      */
15 |     private $length;
16 |     /**
17 |      * @var bool
18 |      */
19 |     private $replacement;
20 | 
21 |     /**
22 |      * Map constructor.
23 |      * @param int $offset
24 |      */
25 |     public function __construct($offset, $length = null, $replacement = null)
26 |     {
27 |         $this->offset = $offset;
28 |         $this->length = $length;
29 |         $this->replacement = $replacement;
30 |     }
31 | 
32 |     public function __invoke(array &$value)
33 |     {
34 |         return array_splice($value, $this->offset, $this->length, $this->replacement);
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/chainy/ReduceKeyValue.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy;
 4 | 
 5 | class ReduceKeyValue
 6 | {
 7 |     /**
 8 |      * @var callable
 9 |      */
10 |     private $callback;
11 |     /**
12 |      * @var mixed
13 |      */
14 |     private $initial;
15 | 
16 |     /**
17 |      * Map constructor.
18 |      * @param callable $callback
19 |      * @param mixed $initial
20 |      */
21 |     public function __construct(callable $callback, $initial = null)
22 |     {
23 |         $this->callback = $callback;
24 |         $this->initial = $initial;
25 |     }
26 | 
27 |     public function __invoke(array $input)
28 |     {
29 |         $carry = $this->initial;
30 |         foreach ($input as $key => $val) {
31 |             $carry = call_user_func($this->callback, $carry, $val, $key);
32 |         }
33 |         return $carry;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/test/SubstrTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Substr;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class SubstrTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $str
12 |      * @param $start
13 |      * @param $length
14 |      * @dataProvider provider_testInvoke
15 |      */
16 |     function testInvoke($str, $start, $length, $expected)
17 |     {
18 |         $this->assertEquals($expected, (new Substr($start, $length))($str));
19 |     }
20 | 
21 |     function provider_testInvoke()
22 |     {
23 |         return [
24 |             ["Hello world", 0, null, "Hello world"],
25 |             ["Hello world", 0, 5, "Hello"],
26 |             ["Hello world", 5, 5, " worl"],
27 |             ["Hello world", -5, null, "world"],
28 |             ["Hello world", -5, 3, "wor"],
29 |         ];
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/test/ReduceTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Reduce;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ReduceTest extends TestCase
 9 | {
10 |     /**
11 |      * @dataProvider provider_testInvoke
12 |      */
13 |     function testInvoke($array, $initial, $expected)
14 |     {
15 |         $sum = function($a, $b) {
16 |             return $a + $b;
17 |         };
18 |         $reduce = new Reduce($sum, $initial);
19 |         $this->assertEquals($expected, $reduce($array));
20 |     }
21 | 
22 |     function provider_testInvoke()
23 |     {
24 |         return [
25 |             [
26 |                 [1, 2, 3],
27 |                 null,
28 |                 6
29 |             ],
30 |             [
31 |                 [1, 2, 3],
32 |                 10,
33 |                 16
34 |             ],
35 |         ];
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/test/StripTagsTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\StripTags;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class StripTagsTest extends TestCase
 9 | {
10 |     /**
11 |      * @param $input
12 |      * @param $allowed
13 |      * @param $expected
14 |      * @dataProvider provider_testInvoke
15 |      */
16 |     function testInvoke($input, $allowed, $expected)
17 |     {
18 |         $this->assertEquals($expected, (new StripTags($allowed))($input));
19 |     }
20 | 
21 |     function provider_testInvoke()
22 |     {
23 |         return [
24 |             ["string without tags", "", "string without tags"],
25 |             ["<div>some <p>text</p></div>", "", "some text"],
26 |             ["<div>some <p>text</p></div>", "<p>", "some <p>text</p>"],
27 |             ["<div>some <p attr=\"value\">text</p></div>", "<p>", "some <p attr=\"value\">text</p>"],
28 |         ];
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/test/ReduceKeyValueTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Reduce;
 6 | use chainy\ReduceKeyValue;
 7 | use PHPUnit\Framework\TestCase;
 8 | 
 9 | class ReduceKeyValueTest extends TestCase
10 | {
11 |     /**
12 |      * @dataProvider provider_testInvoke
13 |      */
14 |     function testInvoke($array, $initial, $expected)
15 |     {
16 |         $func = function($carry, $item, $key) {
17 |             return $carry . ":" . $key . ":" . $item;
18 |         };
19 |         $reduce = new ReduceKeyValue($func, $initial);
20 |         $this->assertEquals($expected, $reduce($array));
21 |     }
22 | 
23 |     function provider_testInvoke()
24 |     {
25 |         return [
26 |             [
27 |                 ["k1" => "v1"],
28 |                 null,
29 |                 ":k1:v1"
30 |             ],
31 |             [
32 |                 ["k1" => "v1", "k2" => "v2"],
33 |                 "prefix",
34 |                 "prefix:k1:v1:k2:v2"
35 |             ],
36 |         ];
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/test/ChainTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Chain;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class ChainTest extends TestCase
 9 | {
10 |     function testApplyCallsAllFiltersAndReturnsTheLastResult()
11 |     {
12 |         $f1Called = false;
13 |         $f1 = function() use (&$f1Called) {
14 |             $f1Called = true;
15 |             return 1;
16 |         };
17 | 
18 |         $f2Called = false;
19 |         $f2Result = 2;
20 |         $f2 = function() use (&$f2Called, $f2Result) {
21 |             $f2Called = true;
22 |             return $f2Result;
23 |         };
24 | 
25 |         $result = (new Chain())->add($f1)->add($f2)->apply("anything");
26 |         $this->assertEquals($f2Result, $result);
27 |         $this->assertTrue($f1Called);
28 |         $this->assertTrue($f2Called);
29 |     }
30 | 
31 |     public function testImmutability()
32 |     {
33 |         $chain1 = new Chain();
34 |         $chain2 = $chain1->add(function(){});
35 |         $this->assertEquals(get_class($chain1), get_class($chain2));
36 |         $this->assertNotSame($chain1, $chain2);
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/test/SliceTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Slice;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class SliceTest extends TestCase
 9 | {
10 |     function testInvoke()
11 |     {
12 |         $arr = [1, 2, 3];
13 |         $this->assertNumericSlices($arr);
14 |     }
15 | 
16 |     function testPreserveKeys()
17 |     {
18 |         $arr = [1, 2, 3];
19 |         $this->assertNumericSlices($arr);
20 |         $this->assertEquals([1 => 2, 2 => 3], (new Slice(1, 2, true))($arr));
21 |     }
22 | 
23 |     function testStringKeysAreAlwaysPreserved()
24 |     {
25 |         $arr = ["a" => 1, "b" => 2, "c" => 3];
26 |         $this->assertEquals(["b" => 2, "c" => 3], (new Slice(1, 2, false))($arr));
27 |         $this->assertEquals(["b" => 2, "c" => 3], (new Slice(1, 2, true))($arr));
28 |     }
29 | 
30 |     protected function assertNumericSlices($arr)
31 |     {
32 |         $this->assertEquals([1, 2], (new Slice(0, 2, false))($arr));
33 |         $this->assertEquals([2, 3], (new Slice(1, null, false))($arr));
34 |         $this->assertEquals([2, 3], (new Slice(1, 2, false))($arr));
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/test/FilterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace chainy\test;
 4 | 
 5 | use chainy\Filter;
 6 | use PHPUnit\Framework\TestCase;
 7 | 
 8 | class FilterTest extends TestCase
 9 | {
10 |     function testDefaultFiltering()
11 |     {
12 |         $this->assertEquals([3 => "value"], (new Filter())(["", false, 0, "value", []]));
13 |     }
14 | 
15 |     function testCustomFiltering()
16 |     {
17 |         $f = function($s) {
18 |             return $s > 2;
19 |         };
20 |         $this->assertEquals([10, 20], (new Filter($f))([10, 20, 0, -1, 1]));
21 |     }
22 | 
23 |     /**
24 |      * Array for testing flag filter
25 |      * @var array
26 |      */
27 |     protected $array = ["a" => 1, "b" => 2, "c" => 3, "d" => 4];
28 | 
29 |     function testDefaultFlagFiltering()
30 |     {
31 |         $f = function($v) {
32 |             return $v === 1;
33 |         };
34 |         $this->assertEquals(["a" => 1], (new Filter($f))($this->array));
35 |     }
36 | 
37 |     function testKeyFlagFiltering()
38 |     {
39 |         $f = function($k) {
40 |             return $k === "c";
41 |         };
42 |         $this->assertEquals(["c" => 3], (new Filter($f, ARRAY_FILTER_USE_KEY))($this->array));
43 |     }
44 | 
45 |     function testBothFlagFiltering()
46 |     {
47 |         $f = function($v, $k) {
48 |             return $v === 4 or $k === "b";
49 |         };
50 |         $this->assertEquals(["b" => 2, "d" => 4], (new Filter($f, ARRAY_FILTER_USE_BOTH))($this->array));
51 |     }
52 | }
53 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Chainy - a nicer way to apply a set of functions to a value
 2 | 
 3 | Have you ever written code like this?
 4 | 
 5 | ```php
 6 | $array = array_filter($array);
 7 | $array = array_map(
 8 |     $array,
 9 |     function($element) {
10 |         // ... manipulations ...
11 |         return $modifiedElement;
12 |     }
13 | );
14 | sort($array);
15 | ```
16 | 
17 | Know what? You could do the same in a more readable and nice way:
18 | 
19 | ```php
20 | 
21 | $chain = (new \chainy\Chain)
22 | 
23 |     ->filter()
24 | 
25 |     ->map(
26 |         function($element) {
27 |             // ... manipulations ...
28 |             return $modifiedElement;
29 |         }
30 |     )
31 | 
32 |     ->sort();
33 | 
34 | $array = $chain->apply($array);
35 | ```
36 | 
37 | Chainy is a pipeline of functions, where every next one gets input from the previous one's output. In the example above,
38 | when _$chain->apply()_ is called on _$array_, it goes sequentially through  _filter()_, _map()_ and _sort()_. As you can expect, those methods are just wrappers for the PHP's built-in functions _array_filter_, _array_map_ and _sort_.
39 | 
40 | This is how things go with chainy:
41 | 
42 | 1. Create new Chain instance.
43 | 1. Setup the pipeline, adding elements to the chain (in this casem _filter_ to get rid of empty element, _map_ to apply some modifications to every element that survived filter, and then sort the resulting array).
44 | 1. Call Chain->apply() on the input array. The result is the filtered, modified and sorted array.
45 | 
46 | ```php
47 | $chain = (new \chainy\Chain)
48 | 
49 | +------> filter() --+
50 | |                   |
51 | |    +--------------+
52 | |    |
53 | |    +-> map(function()...) --+
54 | |                             |
55 | |    +------------------------+
56 | |    |
57 | |    +-> sort();
58 | |
59 | | $array = $chain->apply($array);
60 | |                          |
61 | |--------------------------+
62 | ```
63 | 
64 | 


--------------------------------------------------------------------------------
/src/chainy/Chain.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace chainy;
  4 | 
  5 | class Chain
  6 | {
  7 |     /**
  8 |      * @var callable[]
  9 |      */
 10 |     private $links = [];
 11 |     /**
 12 |      * @param callable $link
 13 |      * @return self
 14 |      */
 15 |     function add(callable $link)
 16 |     {
 17 |         $retval = clone $this;
 18 |         $retval->links[] = $link;
 19 |         return $retval;
 20 |     }
 21 | 
 22 |     /**
 23 |      * @param callable $callback
 24 |      * @param bool $keys whether to pass the input array keys to the callback
 25 |      * @return self
 26 |      */
 27 |     function map(callable $callback, bool $keys = false)
 28 |     {
 29 |         $link = $keys ? new MapKeyValue($callback) : new Map($callback);
 30 |         return $this->add($link);
 31 |     }
 32 | 
 33 |     /**
 34 |      * @param callable $callback
 35 |      * @param mixed $initial
 36 |      * @param bool $keys whether to pass the input array keys to the callback
 37 |      * @return mixed
 38 |      */
 39 |     function reduce(callable $callback, $initial = null, bool $keys = false)
 40 |     {
 41 |         $link = $keys ? new ReduceKeyValue($callback, $initial) : new Map($callback, $initial);
 42 |         return $this->add($link);
 43 |     }
 44 | 
 45 |     /**
 46 |      * @param callable $callback
 47 |      * @param integer $flag
 48 |      * @return mixed
 49 |      */
 50 |     function filter(callable $callback = null, $flag = Filter::FLAG_DEFAULT)
 51 |     {
 52 |         return $this->add(new Filter($callback, $flag));
 53 |     }
 54 | 
 55 |     /**
 56 |      * @param int $offset
 57 |      * @param int $length
 58 |      * @param bool $preserveKeys
 59 |      * @return self
 60 |      */
 61 |     function slice($offset, $length = null, $preserveKeys = null)
 62 |     {
 63 |         return $this->add(new Slice($offset, $length, $preserveKeys));
 64 |     }
 65 | 
 66 |     /**
 67 |      * @param int $offset
 68 |      * @param int $length
 69 |      * @param array $replacement
 70 |      * @return self
 71 |      */
 72 |     function splice($offset, $length = null, $replacement = null)
 73 |     {
 74 |         return $this->add(new Splice($offset, $length, $replacement));
 75 |     }
 76 | 
 77 |     /**
 78 |      * @param callable $callback
 79 |      * @return self
 80 |      */
 81 |     function each(callable $callback)
 82 |     {
 83 |         return $this->add(new Each($callback));
 84 |     }
 85 | 
 86 |     /**
 87 |      * @param \array[] ...$args
 88 |      * @return self
 89 |      */
 90 |     function merge(array ...$args)
 91 |     {
 92 |         return $this->add(new Merge(...$args));
 93 |     }
 94 | 
 95 |     /**
 96 |      * @param array $keys
 97 |      * @return self
 98 |      */
 99 |     function combineWithKeys(array $keys)
100 |     {
101 |         return $this->add(new CombineWithKeys($keys));
102 |     }
103 | 
104 |     /**
105 |      * @param array $values
106 |      * @return self
107 |      */
108 |     function combineWithValues(array $values)
109 |     {
110 |         return $this->add(new CombineWithValues($values));
111 |     }
112 | 
113 |     /**
114 |      * @param string $delimiter
115 |      * @return self
116 |      */
117 |     function split(string $delimiter)
118 |     {
119 |         return $this->add(new Split($delimiter));
120 |     }
121 | 
122 |     /**
123 |      * @param string $glue
124 |      * @return self
125 |      */
126 |     function join(string $glue = "")
127 |     {
128 |         return $this->add(new Join($glue));
129 |     }
130 | 
131 |     /**
132 |      * @param string $chars
133 |      * @return self
134 |      */
135 |     function trim($chars = null)
136 |     {
137 |         return $this->add(new Trim($chars));
138 |     }
139 | 
140 |     /**
141 |      * @param string $chars
142 |      * @return self
143 |      */
144 |     function ltrim($chars = null)
145 |     {
146 |         return $this->add(new Ltrim($chars));
147 |     }
148 | 
149 |     /**
150 |      * @param string $chars
151 |      * @return self
152 |      */
153 |     function rtrim($chars = null)
154 |     {
155 |         return $this->add(new Rtrim($chars));
156 |     }
157 | 
158 |     /**
159 |      * @param string $allowed
160 |      * @return self
161 |      */
162 |     function stripTags($allowed = null)
163 |     {
164 |         return $this->add(new StripTags($allowed));
165 |     }
166 | 
167 |     /**
168 |      * @return self
169 |      */
170 |     function stripLow()
171 |     {
172 |         return $this->add(new StripLow());
173 |     }
174 | 
175 |     /**
176 |      * @return self
177 |      */
178 |     function stripHigh()
179 |     {
180 |         return $this->add(new StripHigh());
181 |     }
182 | 
183 |     /**
184 |      * @param $search
185 |      * @param $replacement
186 |      * @return self
187 |      */
188 |     function strReplace($search, $replacement)
189 |     {
190 |         return $this->add(new StrReplace($search, $replacement));
191 |     }
192 | 
193 |     /**
194 |      * @return self
195 |      */
196 |     function toLowerCase()
197 |     {
198 |         return $this->add(new LowerCase());
199 |     }
200 | 
201 |     /**
202 |      * @return self
203 |      */
204 |     function toUpperCase()
205 |     {
206 |         return $this->add(new UpperCase());
207 |     }
208 | 
209 |     /**
210 |      * @return self
211 |      */
212 |     function capitalize()
213 |     {
214 |         return $this->add(new Capitalize());
215 |     }
216 | 
217 |     /**
218 |      * @return self
219 |      */
220 |     function ucfirst()
221 |     {
222 |         return $this->add(new Ucfirst());
223 |     }
224 | 
225 |     /**
226 |      * @param $value
227 |      * @return mixed
228 |      */
229 |     function apply($value)
230 |     {
231 |         foreach ($this->links as $link) {
232 |             $value = $link($value);
233 |         }
234 |         return $value;
235 |     }
236 | 
237 |     /**
238 |      * @param $value
239 |      * @return mixed
240 |      */
241 |     function __invoke($value)
242 |     {
243 |         return $this->apply($value);
244 |     }
245 | }
246 | 


--------------------------------------------------------------------------------
/composer.lock:
--------------------------------------------------------------------------------
   1 | {
   2 |     "_readme": [
   3 |         "This file locks the dependencies of your project to a known state",
   4 |         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
   5 |         "This file is @generated automatically"
   6 |     ],
   7 |     "content-hash": "1e6f65e5496ba049a5e644ac4e3cf26e",
   8 |     "packages": [],
   9 |     "packages-dev": [
  10 |         {
  11 |             "name": "doctrine/instantiator",
  12 |             "version": "1.1.0",
  13 |             "source": {
  14 |                 "type": "git",
  15 |                 "url": "https://github.com/doctrine/instantiator.git",
  16 |                 "reference": "185b8868aa9bf7159f5f953ed5afb2d7fcdc3bda"
  17 |             },
  18 |             "dist": {
  19 |                 "type": "zip",
  20 |                 "url": "https://api.github.com/repos/doctrine/instantiator/zipball/185b8868aa9bf7159f5f953ed5afb2d7fcdc3bda",
  21 |                 "reference": "185b8868aa9bf7159f5f953ed5afb2d7fcdc3bda",
  22 |                 "shasum": ""
  23 |             },
  24 |             "require": {
  25 |                 "php": "^7.1"
  26 |             },
  27 |             "require-dev": {
  28 |                 "athletic/athletic": "~0.1.8",
  29 |                 "ext-pdo": "*",
  30 |                 "ext-phar": "*",
  31 |                 "phpunit/phpunit": "^6.2.3",
  32 |                 "squizlabs/php_codesniffer": "^3.0.2"
  33 |             },
  34 |             "type": "library",
  35 |             "extra": {
  36 |                 "branch-alias": {
  37 |                     "dev-master": "1.2.x-dev"
  38 |                 }
  39 |             },
  40 |             "autoload": {
  41 |                 "psr-4": {
  42 |                     "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/"
  43 |                 }
  44 |             },
  45 |             "notification-url": "https://packagist.org/downloads/",
  46 |             "license": [
  47 |                 "MIT"
  48 |             ],
  49 |             "authors": [
  50 |                 {
  51 |                     "name": "Marco Pivetta",
  52 |                     "email": "ocramius@gmail.com",
  53 |                     "homepage": "http://ocramius.github.com/"
  54 |                 }
  55 |             ],
  56 |             "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
  57 |             "homepage": "https://github.com/doctrine/instantiator",
  58 |             "keywords": [
  59 |                 "constructor",
  60 |                 "instantiate"
  61 |             ],
  62 |             "time": "2017-07-22T11:58:36+00:00"
  63 |         },
  64 |         {
  65 |             "name": "myclabs/deep-copy",
  66 |             "version": "1.8.1",
  67 |             "source": {
  68 |                 "type": "git",
  69 |                 "url": "https://github.com/myclabs/DeepCopy.git",
  70 |                 "reference": "3e01bdad3e18354c3dce54466b7fbe33a9f9f7f8"
  71 |             },
  72 |             "dist": {
  73 |                 "type": "zip",
  74 |                 "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/3e01bdad3e18354c3dce54466b7fbe33a9f9f7f8",
  75 |                 "reference": "3e01bdad3e18354c3dce54466b7fbe33a9f9f7f8",
  76 |                 "shasum": ""
  77 |             },
  78 |             "require": {
  79 |                 "php": "^7.1"
  80 |             },
  81 |             "replace": {
  82 |                 "myclabs/deep-copy": "self.version"
  83 |             },
  84 |             "require-dev": {
  85 |                 "doctrine/collections": "^1.0",
  86 |                 "doctrine/common": "^2.6",
  87 |                 "phpunit/phpunit": "^7.1"
  88 |             },
  89 |             "type": "library",
  90 |             "autoload": {
  91 |                 "psr-4": {
  92 |                     "DeepCopy\\": "src/DeepCopy/"
  93 |                 },
  94 |                 "files": [
  95 |                     "src/DeepCopy/deep_copy.php"
  96 |                 ]
  97 |             },
  98 |             "notification-url": "https://packagist.org/downloads/",
  99 |             "license": [
 100 |                 "MIT"
 101 |             ],
 102 |             "description": "Create deep copies (clones) of your objects",
 103 |             "keywords": [
 104 |                 "clone",
 105 |                 "copy",
 106 |                 "duplicate",
 107 |                 "object",
 108 |                 "object graph"
 109 |             ],
 110 |             "time": "2018-06-11T23:09:50+00:00"
 111 |         },
 112 |         {
 113 |             "name": "phar-io/manifest",
 114 |             "version": "1.0.1",
 115 |             "source": {
 116 |                 "type": "git",
 117 |                 "url": "https://github.com/phar-io/manifest.git",
 118 |                 "reference": "2df402786ab5368a0169091f61a7c1e0eb6852d0"
 119 |             },
 120 |             "dist": {
 121 |                 "type": "zip",
 122 |                 "url": "https://api.github.com/repos/phar-io/manifest/zipball/2df402786ab5368a0169091f61a7c1e0eb6852d0",
 123 |                 "reference": "2df402786ab5368a0169091f61a7c1e0eb6852d0",
 124 |                 "shasum": ""
 125 |             },
 126 |             "require": {
 127 |                 "ext-dom": "*",
 128 |                 "ext-phar": "*",
 129 |                 "phar-io/version": "^1.0.1",
 130 |                 "php": "^5.6 || ^7.0"
 131 |             },
 132 |             "type": "library",
 133 |             "extra": {
 134 |                 "branch-alias": {
 135 |                     "dev-master": "1.0.x-dev"
 136 |                 }
 137 |             },
 138 |             "autoload": {
 139 |                 "classmap": [
 140 |                     "src/"
 141 |                 ]
 142 |             },
 143 |             "notification-url": "https://packagist.org/downloads/",
 144 |             "license": [
 145 |                 "BSD-3-Clause"
 146 |             ],
 147 |             "authors": [
 148 |                 {
 149 |                     "name": "Arne Blankerts",
 150 |                     "email": "arne@blankerts.de",
 151 |                     "role": "Developer"
 152 |                 },
 153 |                 {
 154 |                     "name": "Sebastian Heuer",
 155 |                     "email": "sebastian@phpeople.de",
 156 |                     "role": "Developer"
 157 |                 },
 158 |                 {
 159 |                     "name": "Sebastian Bergmann",
 160 |                     "email": "sebastian@phpunit.de",
 161 |                     "role": "Developer"
 162 |                 }
 163 |             ],
 164 |             "description": "Component for reading phar.io manifest information from a PHP Archive (PHAR)",
 165 |             "time": "2017-03-05T18:14:27+00:00"
 166 |         },
 167 |         {
 168 |             "name": "phar-io/version",
 169 |             "version": "1.0.1",
 170 |             "source": {
 171 |                 "type": "git",
 172 |                 "url": "https://github.com/phar-io/version.git",
 173 |                 "reference": "a70c0ced4be299a63d32fa96d9281d03e94041df"
 174 |             },
 175 |             "dist": {
 176 |                 "type": "zip",
 177 |                 "url": "https://api.github.com/repos/phar-io/version/zipball/a70c0ced4be299a63d32fa96d9281d03e94041df",
 178 |                 "reference": "a70c0ced4be299a63d32fa96d9281d03e94041df",
 179 |                 "shasum": ""
 180 |             },
 181 |             "require": {
 182 |                 "php": "^5.6 || ^7.0"
 183 |             },
 184 |             "type": "library",
 185 |             "autoload": {
 186 |                 "classmap": [
 187 |                     "src/"
 188 |                 ]
 189 |             },
 190 |             "notification-url": "https://packagist.org/downloads/",
 191 |             "license": [
 192 |                 "BSD-3-Clause"
 193 |             ],
 194 |             "authors": [
 195 |                 {
 196 |                     "name": "Arne Blankerts",
 197 |                     "email": "arne@blankerts.de",
 198 |                     "role": "Developer"
 199 |                 },
 200 |                 {
 201 |                     "name": "Sebastian Heuer",
 202 |                     "email": "sebastian@phpeople.de",
 203 |                     "role": "Developer"
 204 |                 },
 205 |                 {
 206 |                     "name": "Sebastian Bergmann",
 207 |                     "email": "sebastian@phpunit.de",
 208 |                     "role": "Developer"
 209 |                 }
 210 |             ],
 211 |             "description": "Library for handling version information and constraints",
 212 |             "time": "2017-03-05T17:38:23+00:00"
 213 |         },
 214 |         {
 215 |             "name": "phpdocumentor/reflection-common",
 216 |             "version": "1.0.1",
 217 |             "source": {
 218 |                 "type": "git",
 219 |                 "url": "https://github.com/phpDocumentor/ReflectionCommon.git",
 220 |                 "reference": "21bdeb5f65d7ebf9f43b1b25d404f87deab5bfb6"
 221 |             },
 222 |             "dist": {
 223 |                 "type": "zip",
 224 |                 "url": "https://api.github.com/repos/phpDocumentor/ReflectionCommon/zipball/21bdeb5f65d7ebf9f43b1b25d404f87deab5bfb6",
 225 |                 "reference": "21bdeb5f65d7ebf9f43b1b25d404f87deab5bfb6",
 226 |                 "shasum": ""
 227 |             },
 228 |             "require": {
 229 |                 "php": ">=5.5"
 230 |             },
 231 |             "require-dev": {
 232 |                 "phpunit/phpunit": "^4.6"
 233 |             },
 234 |             "type": "library",
 235 |             "extra": {
 236 |                 "branch-alias": {
 237 |                     "dev-master": "1.0.x-dev"
 238 |                 }
 239 |             },
 240 |             "autoload": {
 241 |                 "psr-4": {
 242 |                     "phpDocumentor\\Reflection\\": [
 243 |                         "src"
 244 |                     ]
 245 |                 }
 246 |             },
 247 |             "notification-url": "https://packagist.org/downloads/",
 248 |             "license": [
 249 |                 "MIT"
 250 |             ],
 251 |             "authors": [
 252 |                 {
 253 |                     "name": "Jaap van Otterdijk",
 254 |                     "email": "opensource@ijaap.nl"
 255 |                 }
 256 |             ],
 257 |             "description": "Common reflection classes used by phpdocumentor to reflect the code structure",
 258 |             "homepage": "http://www.phpdoc.org",
 259 |             "keywords": [
 260 |                 "FQSEN",
 261 |                 "phpDocumentor",
 262 |                 "phpdoc",
 263 |                 "reflection",
 264 |                 "static analysis"
 265 |             ],
 266 |             "time": "2017-09-11T18:02:19+00:00"
 267 |         },
 268 |         {
 269 |             "name": "phpdocumentor/reflection-docblock",
 270 |             "version": "4.3.0",
 271 |             "source": {
 272 |                 "type": "git",
 273 |                 "url": "https://github.com/phpDocumentor/ReflectionDocBlock.git",
 274 |                 "reference": "94fd0001232e47129dd3504189fa1c7225010d08"
 275 |             },
 276 |             "dist": {
 277 |                 "type": "zip",
 278 |                 "url": "https://api.github.com/repos/phpDocumentor/ReflectionDocBlock/zipball/94fd0001232e47129dd3504189fa1c7225010d08",
 279 |                 "reference": "94fd0001232e47129dd3504189fa1c7225010d08",
 280 |                 "shasum": ""
 281 |             },
 282 |             "require": {
 283 |                 "php": "^7.0",
 284 |                 "phpdocumentor/reflection-common": "^1.0.0",
 285 |                 "phpdocumentor/type-resolver": "^0.4.0",
 286 |                 "webmozart/assert": "^1.0"
 287 |             },
 288 |             "require-dev": {
 289 |                 "doctrine/instantiator": "~1.0.5",
 290 |                 "mockery/mockery": "^1.0",
 291 |                 "phpunit/phpunit": "^6.4"
 292 |             },
 293 |             "type": "library",
 294 |             "extra": {
 295 |                 "branch-alias": {
 296 |                     "dev-master": "4.x-dev"
 297 |                 }
 298 |             },
 299 |             "autoload": {
 300 |                 "psr-4": {
 301 |                     "phpDocumentor\\Reflection\\": [
 302 |                         "src/"
 303 |                     ]
 304 |                 }
 305 |             },
 306 |             "notification-url": "https://packagist.org/downloads/",
 307 |             "license": [
 308 |                 "MIT"
 309 |             ],
 310 |             "authors": [
 311 |                 {
 312 |                     "name": "Mike van Riel",
 313 |                     "email": "me@mikevanriel.com"
 314 |                 }
 315 |             ],
 316 |             "description": "With this component, a library can provide support for annotations via DocBlocks or otherwise retrieve information that is embedded in a DocBlock.",
 317 |             "time": "2017-11-30T07:14:17+00:00"
 318 |         },
 319 |         {
 320 |             "name": "phpdocumentor/type-resolver",
 321 |             "version": "0.4.0",
 322 |             "source": {
 323 |                 "type": "git",
 324 |                 "url": "https://github.com/phpDocumentor/TypeResolver.git",
 325 |                 "reference": "9c977708995954784726e25d0cd1dddf4e65b0f7"
 326 |             },
 327 |             "dist": {
 328 |                 "type": "zip",
 329 |                 "url": "https://api.github.com/repos/phpDocumentor/TypeResolver/zipball/9c977708995954784726e25d0cd1dddf4e65b0f7",
 330 |                 "reference": "9c977708995954784726e25d0cd1dddf4e65b0f7",
 331 |                 "shasum": ""
 332 |             },
 333 |             "require": {
 334 |                 "php": "^5.5 || ^7.0",
 335 |                 "phpdocumentor/reflection-common": "^1.0"
 336 |             },
 337 |             "require-dev": {
 338 |                 "mockery/mockery": "^0.9.4",
 339 |                 "phpunit/phpunit": "^5.2||^4.8.24"
 340 |             },
 341 |             "type": "library",
 342 |             "extra": {
 343 |                 "branch-alias": {
 344 |                     "dev-master": "1.0.x-dev"
 345 |                 }
 346 |             },
 347 |             "autoload": {
 348 |                 "psr-4": {
 349 |                     "phpDocumentor\\Reflection\\": [
 350 |                         "src/"
 351 |                     ]
 352 |                 }
 353 |             },
 354 |             "notification-url": "https://packagist.org/downloads/",
 355 |             "license": [
 356 |                 "MIT"
 357 |             ],
 358 |             "authors": [
 359 |                 {
 360 |                     "name": "Mike van Riel",
 361 |                     "email": "me@mikevanriel.com"
 362 |                 }
 363 |             ],
 364 |             "time": "2017-07-14T14:27:02+00:00"
 365 |         },
 366 |         {
 367 |             "name": "phpspec/prophecy",
 368 |             "version": "1.8.0",
 369 |             "source": {
 370 |                 "type": "git",
 371 |                 "url": "https://github.com/phpspec/prophecy.git",
 372 |                 "reference": "4ba436b55987b4bf311cb7c6ba82aa528aac0a06"
 373 |             },
 374 |             "dist": {
 375 |                 "type": "zip",
 376 |                 "url": "https://api.github.com/repos/phpspec/prophecy/zipball/4ba436b55987b4bf311cb7c6ba82aa528aac0a06",
 377 |                 "reference": "4ba436b55987b4bf311cb7c6ba82aa528aac0a06",
 378 |                 "shasum": ""
 379 |             },
 380 |             "require": {
 381 |                 "doctrine/instantiator": "^1.0.2",
 382 |                 "php": "^5.3|^7.0",
 383 |                 "phpdocumentor/reflection-docblock": "^2.0|^3.0.2|^4.0",
 384 |                 "sebastian/comparator": "^1.1|^2.0|^3.0",
 385 |                 "sebastian/recursion-context": "^1.0|^2.0|^3.0"
 386 |             },
 387 |             "require-dev": {
 388 |                 "phpspec/phpspec": "^2.5|^3.2",
 389 |                 "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.5 || ^7.1"
 390 |             },
 391 |             "type": "library",
 392 |             "extra": {
 393 |                 "branch-alias": {
 394 |                     "dev-master": "1.8.x-dev"
 395 |                 }
 396 |             },
 397 |             "autoload": {
 398 |                 "psr-0": {
 399 |                     "Prophecy\\": "src/"
 400 |                 }
 401 |             },
 402 |             "notification-url": "https://packagist.org/downloads/",
 403 |             "license": [
 404 |                 "MIT"
 405 |             ],
 406 |             "authors": [
 407 |                 {
 408 |                     "name": "Konstantin Kudryashov",
 409 |                     "email": "ever.zet@gmail.com",
 410 |                     "homepage": "http://everzet.com"
 411 |                 },
 412 |                 {
 413 |                     "name": "Marcello Duarte",
 414 |                     "email": "marcello.duarte@gmail.com"
 415 |                 }
 416 |             ],
 417 |             "description": "Highly opinionated mocking framework for PHP 5.3+",
 418 |             "homepage": "https://github.com/phpspec/prophecy",
 419 |             "keywords": [
 420 |                 "Double",
 421 |                 "Dummy",
 422 |                 "fake",
 423 |                 "mock",
 424 |                 "spy",
 425 |                 "stub"
 426 |             ],
 427 |             "time": "2018-08-05T17:53:17+00:00"
 428 |         },
 429 |         {
 430 |             "name": "phpunit/php-code-coverage",
 431 |             "version": "5.3.2",
 432 |             "source": {
 433 |                 "type": "git",
 434 |                 "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
 435 |                 "reference": "c89677919c5dd6d3b3852f230a663118762218ac"
 436 |             },
 437 |             "dist": {
 438 |                 "type": "zip",
 439 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/c89677919c5dd6d3b3852f230a663118762218ac",
 440 |                 "reference": "c89677919c5dd6d3b3852f230a663118762218ac",
 441 |                 "shasum": ""
 442 |             },
 443 |             "require": {
 444 |                 "ext-dom": "*",
 445 |                 "ext-xmlwriter": "*",
 446 |                 "php": "^7.0",
 447 |                 "phpunit/php-file-iterator": "^1.4.2",
 448 |                 "phpunit/php-text-template": "^1.2.1",
 449 |                 "phpunit/php-token-stream": "^2.0.1",
 450 |                 "sebastian/code-unit-reverse-lookup": "^1.0.1",
 451 |                 "sebastian/environment": "^3.0",
 452 |                 "sebastian/version": "^2.0.1",
 453 |                 "theseer/tokenizer": "^1.1"
 454 |             },
 455 |             "require-dev": {
 456 |                 "phpunit/phpunit": "^6.0"
 457 |             },
 458 |             "suggest": {
 459 |                 "ext-xdebug": "^2.5.5"
 460 |             },
 461 |             "type": "library",
 462 |             "extra": {
 463 |                 "branch-alias": {
 464 |                     "dev-master": "5.3.x-dev"
 465 |                 }
 466 |             },
 467 |             "autoload": {
 468 |                 "classmap": [
 469 |                     "src/"
 470 |                 ]
 471 |             },
 472 |             "notification-url": "https://packagist.org/downloads/",
 473 |             "license": [
 474 |                 "BSD-3-Clause"
 475 |             ],
 476 |             "authors": [
 477 |                 {
 478 |                     "name": "Sebastian Bergmann",
 479 |                     "email": "sebastian@phpunit.de",
 480 |                     "role": "lead"
 481 |                 }
 482 |             ],
 483 |             "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.",
 484 |             "homepage": "https://github.com/sebastianbergmann/php-code-coverage",
 485 |             "keywords": [
 486 |                 "coverage",
 487 |                 "testing",
 488 |                 "xunit"
 489 |             ],
 490 |             "time": "2018-04-06T15:36:58+00:00"
 491 |         },
 492 |         {
 493 |             "name": "phpunit/php-file-iterator",
 494 |             "version": "1.4.5",
 495 |             "source": {
 496 |                 "type": "git",
 497 |                 "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
 498 |                 "reference": "730b01bc3e867237eaac355e06a36b85dd93a8b4"
 499 |             },
 500 |             "dist": {
 501 |                 "type": "zip",
 502 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/730b01bc3e867237eaac355e06a36b85dd93a8b4",
 503 |                 "reference": "730b01bc3e867237eaac355e06a36b85dd93a8b4",
 504 |                 "shasum": ""
 505 |             },
 506 |             "require": {
 507 |                 "php": ">=5.3.3"
 508 |             },
 509 |             "type": "library",
 510 |             "extra": {
 511 |                 "branch-alias": {
 512 |                     "dev-master": "1.4.x-dev"
 513 |                 }
 514 |             },
 515 |             "autoload": {
 516 |                 "classmap": [
 517 |                     "src/"
 518 |                 ]
 519 |             },
 520 |             "notification-url": "https://packagist.org/downloads/",
 521 |             "license": [
 522 |                 "BSD-3-Clause"
 523 |             ],
 524 |             "authors": [
 525 |                 {
 526 |                     "name": "Sebastian Bergmann",
 527 |                     "email": "sb@sebastian-bergmann.de",
 528 |                     "role": "lead"
 529 |                 }
 530 |             ],
 531 |             "description": "FilterIterator implementation that filters files based on a list of suffixes.",
 532 |             "homepage": "https://github.com/sebastianbergmann/php-file-iterator/",
 533 |             "keywords": [
 534 |                 "filesystem",
 535 |                 "iterator"
 536 |             ],
 537 |             "time": "2017-11-27T13:52:08+00:00"
 538 |         },
 539 |         {
 540 |             "name": "phpunit/php-text-template",
 541 |             "version": "1.2.1",
 542 |             "source": {
 543 |                 "type": "git",
 544 |                 "url": "https://github.com/sebastianbergmann/php-text-template.git",
 545 |                 "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686"
 546 |             },
 547 |             "dist": {
 548 |                 "type": "zip",
 549 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
 550 |                 "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
 551 |                 "shasum": ""
 552 |             },
 553 |             "require": {
 554 |                 "php": ">=5.3.3"
 555 |             },
 556 |             "type": "library",
 557 |             "autoload": {
 558 |                 "classmap": [
 559 |                     "src/"
 560 |                 ]
 561 |             },
 562 |             "notification-url": "https://packagist.org/downloads/",
 563 |             "license": [
 564 |                 "BSD-3-Clause"
 565 |             ],
 566 |             "authors": [
 567 |                 {
 568 |                     "name": "Sebastian Bergmann",
 569 |                     "email": "sebastian@phpunit.de",
 570 |                     "role": "lead"
 571 |                 }
 572 |             ],
 573 |             "description": "Simple template engine.",
 574 |             "homepage": "https://github.com/sebastianbergmann/php-text-template/",
 575 |             "keywords": [
 576 |                 "template"
 577 |             ],
 578 |             "time": "2015-06-21T13:50:34+00:00"
 579 |         },
 580 |         {
 581 |             "name": "phpunit/php-timer",
 582 |             "version": "1.0.9",
 583 |             "source": {
 584 |                 "type": "git",
 585 |                 "url": "https://github.com/sebastianbergmann/php-timer.git",
 586 |                 "reference": "3dcf38ca72b158baf0bc245e9184d3fdffa9c46f"
 587 |             },
 588 |             "dist": {
 589 |                 "type": "zip",
 590 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/3dcf38ca72b158baf0bc245e9184d3fdffa9c46f",
 591 |                 "reference": "3dcf38ca72b158baf0bc245e9184d3fdffa9c46f",
 592 |                 "shasum": ""
 593 |             },
 594 |             "require": {
 595 |                 "php": "^5.3.3 || ^7.0"
 596 |             },
 597 |             "require-dev": {
 598 |                 "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.0"
 599 |             },
 600 |             "type": "library",
 601 |             "extra": {
 602 |                 "branch-alias": {
 603 |                     "dev-master": "1.0-dev"
 604 |                 }
 605 |             },
 606 |             "autoload": {
 607 |                 "classmap": [
 608 |                     "src/"
 609 |                 ]
 610 |             },
 611 |             "notification-url": "https://packagist.org/downloads/",
 612 |             "license": [
 613 |                 "BSD-3-Clause"
 614 |             ],
 615 |             "authors": [
 616 |                 {
 617 |                     "name": "Sebastian Bergmann",
 618 |                     "email": "sb@sebastian-bergmann.de",
 619 |                     "role": "lead"
 620 |                 }
 621 |             ],
 622 |             "description": "Utility class for timing",
 623 |             "homepage": "https://github.com/sebastianbergmann/php-timer/",
 624 |             "keywords": [
 625 |                 "timer"
 626 |             ],
 627 |             "time": "2017-02-26T11:10:40+00:00"
 628 |         },
 629 |         {
 630 |             "name": "phpunit/php-token-stream",
 631 |             "version": "2.0.2",
 632 |             "source": {
 633 |                 "type": "git",
 634 |                 "url": "https://github.com/sebastianbergmann/php-token-stream.git",
 635 |                 "reference": "791198a2c6254db10131eecfe8c06670700904db"
 636 |             },
 637 |             "dist": {
 638 |                 "type": "zip",
 639 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-token-stream/zipball/791198a2c6254db10131eecfe8c06670700904db",
 640 |                 "reference": "791198a2c6254db10131eecfe8c06670700904db",
 641 |                 "shasum": ""
 642 |             },
 643 |             "require": {
 644 |                 "ext-tokenizer": "*",
 645 |                 "php": "^7.0"
 646 |             },
 647 |             "require-dev": {
 648 |                 "phpunit/phpunit": "^6.2.4"
 649 |             },
 650 |             "type": "library",
 651 |             "extra": {
 652 |                 "branch-alias": {
 653 |                     "dev-master": "2.0-dev"
 654 |                 }
 655 |             },
 656 |             "autoload": {
 657 |                 "classmap": [
 658 |                     "src/"
 659 |                 ]
 660 |             },
 661 |             "notification-url": "https://packagist.org/downloads/",
 662 |             "license": [
 663 |                 "BSD-3-Clause"
 664 |             ],
 665 |             "authors": [
 666 |                 {
 667 |                     "name": "Sebastian Bergmann",
 668 |                     "email": "sebastian@phpunit.de"
 669 |                 }
 670 |             ],
 671 |             "description": "Wrapper around PHP's tokenizer extension.",
 672 |             "homepage": "https://github.com/sebastianbergmann/php-token-stream/",
 673 |             "keywords": [
 674 |                 "tokenizer"
 675 |             ],
 676 |             "time": "2017-11-27T05:48:46+00:00"
 677 |         },
 678 |         {
 679 |             "name": "phpunit/phpunit",
 680 |             "version": "6.5.13",
 681 |             "source": {
 682 |                 "type": "git",
 683 |                 "url": "https://github.com/sebastianbergmann/phpunit.git",
 684 |                 "reference": "0973426fb012359b2f18d3bd1e90ef1172839693"
 685 |             },
 686 |             "dist": {
 687 |                 "type": "zip",
 688 |                 "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/0973426fb012359b2f18d3bd1e90ef1172839693",
 689 |                 "reference": "0973426fb012359b2f18d3bd1e90ef1172839693",
 690 |                 "shasum": ""
 691 |             },
 692 |             "require": {
 693 |                 "ext-dom": "*",
 694 |                 "ext-json": "*",
 695 |                 "ext-libxml": "*",
 696 |                 "ext-mbstring": "*",
 697 |                 "ext-xml": "*",
 698 |                 "myclabs/deep-copy": "^1.6.1",
 699 |                 "phar-io/manifest": "^1.0.1",
 700 |                 "phar-io/version": "^1.0",
 701 |                 "php": "^7.0",
 702 |                 "phpspec/prophecy": "^1.7",
 703 |                 "phpunit/php-code-coverage": "^5.3",
 704 |                 "phpunit/php-file-iterator": "^1.4.3",
 705 |                 "phpunit/php-text-template": "^1.2.1",
 706 |                 "phpunit/php-timer": "^1.0.9",
 707 |                 "phpunit/phpunit-mock-objects": "^5.0.9",
 708 |                 "sebastian/comparator": "^2.1",
 709 |                 "sebastian/diff": "^2.0",
 710 |                 "sebastian/environment": "^3.1",
 711 |                 "sebastian/exporter": "^3.1",
 712 |                 "sebastian/global-state": "^2.0",
 713 |                 "sebastian/object-enumerator": "^3.0.3",
 714 |                 "sebastian/resource-operations": "^1.0",
 715 |                 "sebastian/version": "^2.0.1"
 716 |             },
 717 |             "conflict": {
 718 |                 "phpdocumentor/reflection-docblock": "3.0.2",
 719 |                 "phpunit/dbunit": "<3.0"
 720 |             },
 721 |             "require-dev": {
 722 |                 "ext-pdo": "*"
 723 |             },
 724 |             "suggest": {
 725 |                 "ext-xdebug": "*",
 726 |                 "phpunit/php-invoker": "^1.1"
 727 |             },
 728 |             "bin": [
 729 |                 "phpunit"
 730 |             ],
 731 |             "type": "library",
 732 |             "extra": {
 733 |                 "branch-alias": {
 734 |                     "dev-master": "6.5.x-dev"
 735 |                 }
 736 |             },
 737 |             "autoload": {
 738 |                 "classmap": [
 739 |                     "src/"
 740 |                 ]
 741 |             },
 742 |             "notification-url": "https://packagist.org/downloads/",
 743 |             "license": [
 744 |                 "BSD-3-Clause"
 745 |             ],
 746 |             "authors": [
 747 |                 {
 748 |                     "name": "Sebastian Bergmann",
 749 |                     "email": "sebastian@phpunit.de",
 750 |                     "role": "lead"
 751 |                 }
 752 |             ],
 753 |             "description": "The PHP Unit Testing framework.",
 754 |             "homepage": "https://phpunit.de/",
 755 |             "keywords": [
 756 |                 "phpunit",
 757 |                 "testing",
 758 |                 "xunit"
 759 |             ],
 760 |             "time": "2018-09-08T15:10:43+00:00"
 761 |         },
 762 |         {
 763 |             "name": "phpunit/phpunit-mock-objects",
 764 |             "version": "5.0.10",
 765 |             "source": {
 766 |                 "type": "git",
 767 |                 "url": "https://github.com/sebastianbergmann/phpunit-mock-objects.git",
 768 |                 "reference": "cd1cf05c553ecfec36b170070573e540b67d3f1f"
 769 |             },
 770 |             "dist": {
 771 |                 "type": "zip",
 772 |                 "url": "https://api.github.com/repos/sebastianbergmann/phpunit-mock-objects/zipball/cd1cf05c553ecfec36b170070573e540b67d3f1f",
 773 |                 "reference": "cd1cf05c553ecfec36b170070573e540b67d3f1f",
 774 |                 "shasum": ""
 775 |             },
 776 |             "require": {
 777 |                 "doctrine/instantiator": "^1.0.5",
 778 |                 "php": "^7.0",
 779 |                 "phpunit/php-text-template": "^1.2.1",
 780 |                 "sebastian/exporter": "^3.1"
 781 |             },
 782 |             "conflict": {
 783 |                 "phpunit/phpunit": "<6.0"
 784 |             },
 785 |             "require-dev": {
 786 |                 "phpunit/phpunit": "^6.5.11"
 787 |             },
 788 |             "suggest": {
 789 |                 "ext-soap": "*"
 790 |             },
 791 |             "type": "library",
 792 |             "extra": {
 793 |                 "branch-alias": {
 794 |                     "dev-master": "5.0.x-dev"
 795 |                 }
 796 |             },
 797 |             "autoload": {
 798 |                 "classmap": [
 799 |                     "src/"
 800 |                 ]
 801 |             },
 802 |             "notification-url": "https://packagist.org/downloads/",
 803 |             "license": [
 804 |                 "BSD-3-Clause"
 805 |             ],
 806 |             "authors": [
 807 |                 {
 808 |                     "name": "Sebastian Bergmann",
 809 |                     "email": "sebastian@phpunit.de",
 810 |                     "role": "lead"
 811 |                 }
 812 |             ],
 813 |             "description": "Mock Object library for PHPUnit",
 814 |             "homepage": "https://github.com/sebastianbergmann/phpunit-mock-objects/",
 815 |             "keywords": [
 816 |                 "mock",
 817 |                 "xunit"
 818 |             ],
 819 |             "time": "2018-08-09T05:50:03+00:00"
 820 |         },
 821 |         {
 822 |             "name": "sebastian/code-unit-reverse-lookup",
 823 |             "version": "1.0.1",
 824 |             "source": {
 825 |                 "type": "git",
 826 |                 "url": "https://github.com/sebastianbergmann/code-unit-reverse-lookup.git",
 827 |                 "reference": "4419fcdb5eabb9caa61a27c7a1db532a6b55dd18"
 828 |             },
 829 |             "dist": {
 830 |                 "type": "zip",
 831 |                 "url": "https://api.github.com/repos/sebastianbergmann/code-unit-reverse-lookup/zipball/4419fcdb5eabb9caa61a27c7a1db532a6b55dd18",
 832 |                 "reference": "4419fcdb5eabb9caa61a27c7a1db532a6b55dd18",
 833 |                 "shasum": ""
 834 |             },
 835 |             "require": {
 836 |                 "php": "^5.6 || ^7.0"
 837 |             },
 838 |             "require-dev": {
 839 |                 "phpunit/phpunit": "^5.7 || ^6.0"
 840 |             },
 841 |             "type": "library",
 842 |             "extra": {
 843 |                 "branch-alias": {
 844 |                     "dev-master": "1.0.x-dev"
 845 |                 }
 846 |             },
 847 |             "autoload": {
 848 |                 "classmap": [
 849 |                     "src/"
 850 |                 ]
 851 |             },
 852 |             "notification-url": "https://packagist.org/downloads/",
 853 |             "license": [
 854 |                 "BSD-3-Clause"
 855 |             ],
 856 |             "authors": [
 857 |                 {
 858 |                     "name": "Sebastian Bergmann",
 859 |                     "email": "sebastian@phpunit.de"
 860 |                 }
 861 |             ],
 862 |             "description": "Looks up which function or method a line of code belongs to",
 863 |             "homepage": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/",
 864 |             "time": "2017-03-04T06:30:41+00:00"
 865 |         },
 866 |         {
 867 |             "name": "sebastian/comparator",
 868 |             "version": "2.1.3",
 869 |             "source": {
 870 |                 "type": "git",
 871 |                 "url": "https://github.com/sebastianbergmann/comparator.git",
 872 |                 "reference": "34369daee48eafb2651bea869b4b15d75ccc35f9"
 873 |             },
 874 |             "dist": {
 875 |                 "type": "zip",
 876 |                 "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/34369daee48eafb2651bea869b4b15d75ccc35f9",
 877 |                 "reference": "34369daee48eafb2651bea869b4b15d75ccc35f9",
 878 |                 "shasum": ""
 879 |             },
 880 |             "require": {
 881 |                 "php": "^7.0",
 882 |                 "sebastian/diff": "^2.0 || ^3.0",
 883 |                 "sebastian/exporter": "^3.1"
 884 |             },
 885 |             "require-dev": {
 886 |                 "phpunit/phpunit": "^6.4"
 887 |             },
 888 |             "type": "library",
 889 |             "extra": {
 890 |                 "branch-alias": {
 891 |                     "dev-master": "2.1.x-dev"
 892 |                 }
 893 |             },
 894 |             "autoload": {
 895 |                 "classmap": [
 896 |                     "src/"
 897 |                 ]
 898 |             },
 899 |             "notification-url": "https://packagist.org/downloads/",
 900 |             "license": [
 901 |                 "BSD-3-Clause"
 902 |             ],
 903 |             "authors": [
 904 |                 {
 905 |                     "name": "Jeff Welch",
 906 |                     "email": "whatthejeff@gmail.com"
 907 |                 },
 908 |                 {
 909 |                     "name": "Volker Dusch",
 910 |                     "email": "github@wallbash.com"
 911 |                 },
 912 |                 {
 913 |                     "name": "Bernhard Schussek",
 914 |                     "email": "bschussek@2bepublished.at"
 915 |                 },
 916 |                 {
 917 |                     "name": "Sebastian Bergmann",
 918 |                     "email": "sebastian@phpunit.de"
 919 |                 }
 920 |             ],
 921 |             "description": "Provides the functionality to compare PHP values for equality",
 922 |             "homepage": "https://github.com/sebastianbergmann/comparator",
 923 |             "keywords": [
 924 |                 "comparator",
 925 |                 "compare",
 926 |                 "equality"
 927 |             ],
 928 |             "time": "2018-02-01T13:46:46+00:00"
 929 |         },
 930 |         {
 931 |             "name": "sebastian/diff",
 932 |             "version": "2.0.1",
 933 |             "source": {
 934 |                 "type": "git",
 935 |                 "url": "https://github.com/sebastianbergmann/diff.git",
 936 |                 "reference": "347c1d8b49c5c3ee30c7040ea6fc446790e6bddd"
 937 |             },
 938 |             "dist": {
 939 |                 "type": "zip",
 940 |                 "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/347c1d8b49c5c3ee30c7040ea6fc446790e6bddd",
 941 |                 "reference": "347c1d8b49c5c3ee30c7040ea6fc446790e6bddd",
 942 |                 "shasum": ""
 943 |             },
 944 |             "require": {
 945 |                 "php": "^7.0"
 946 |             },
 947 |             "require-dev": {
 948 |                 "phpunit/phpunit": "^6.2"
 949 |             },
 950 |             "type": "library",
 951 |             "extra": {
 952 |                 "branch-alias": {
 953 |                     "dev-master": "2.0-dev"
 954 |                 }
 955 |             },
 956 |             "autoload": {
 957 |                 "classmap": [
 958 |                     "src/"
 959 |                 ]
 960 |             },
 961 |             "notification-url": "https://packagist.org/downloads/",
 962 |             "license": [
 963 |                 "BSD-3-Clause"
 964 |             ],
 965 |             "authors": [
 966 |                 {
 967 |                     "name": "Kore Nordmann",
 968 |                     "email": "mail@kore-nordmann.de"
 969 |                 },
 970 |                 {
 971 |                     "name": "Sebastian Bergmann",
 972 |                     "email": "sebastian@phpunit.de"
 973 |                 }
 974 |             ],
 975 |             "description": "Diff implementation",
 976 |             "homepage": "https://github.com/sebastianbergmann/diff",
 977 |             "keywords": [
 978 |                 "diff"
 979 |             ],
 980 |             "time": "2017-08-03T08:09:46+00:00"
 981 |         },
 982 |         {
 983 |             "name": "sebastian/environment",
 984 |             "version": "3.1.0",
 985 |             "source": {
 986 |                 "type": "git",
 987 |                 "url": "https://github.com/sebastianbergmann/environment.git",
 988 |                 "reference": "cd0871b3975fb7fc44d11314fd1ee20925fce4f5"
 989 |             },
 990 |             "dist": {
 991 |                 "type": "zip",
 992 |                 "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/cd0871b3975fb7fc44d11314fd1ee20925fce4f5",
 993 |                 "reference": "cd0871b3975fb7fc44d11314fd1ee20925fce4f5",
 994 |                 "shasum": ""
 995 |             },
 996 |             "require": {
 997 |                 "php": "^7.0"
 998 |             },
 999 |             "require-dev": {
1000 |                 "phpunit/phpunit": "^6.1"
1001 |             },
1002 |             "type": "library",
1003 |             "extra": {
1004 |                 "branch-alias": {
1005 |                     "dev-master": "3.1.x-dev"
1006 |                 }
1007 |             },
1008 |             "autoload": {
1009 |                 "classmap": [
1010 |                     "src/"
1011 |                 ]
1012 |             },
1013 |             "notification-url": "https://packagist.org/downloads/",
1014 |             "license": [
1015 |                 "BSD-3-Clause"
1016 |             ],
1017 |             "authors": [
1018 |                 {
1019 |                     "name": "Sebastian Bergmann",
1020 |                     "email": "sebastian@phpunit.de"
1021 |                 }
1022 |             ],
1023 |             "description": "Provides functionality to handle HHVM/PHP environments",
1024 |             "homepage": "http://www.github.com/sebastianbergmann/environment",
1025 |             "keywords": [
1026 |                 "Xdebug",
1027 |                 "environment",
1028 |                 "hhvm"
1029 |             ],
1030 |             "time": "2017-07-01T08:51:00+00:00"
1031 |         },
1032 |         {
1033 |             "name": "sebastian/exporter",
1034 |             "version": "3.1.0",
1035 |             "source": {
1036 |                 "type": "git",
1037 |                 "url": "https://github.com/sebastianbergmann/exporter.git",
1038 |                 "reference": "234199f4528de6d12aaa58b612e98f7d36adb937"
1039 |             },
1040 |             "dist": {
1041 |                 "type": "zip",
1042 |                 "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/234199f4528de6d12aaa58b612e98f7d36adb937",
1043 |                 "reference": "234199f4528de6d12aaa58b612e98f7d36adb937",
1044 |                 "shasum": ""
1045 |             },
1046 |             "require": {
1047 |                 "php": "^7.0",
1048 |                 "sebastian/recursion-context": "^3.0"
1049 |             },
1050 |             "require-dev": {
1051 |                 "ext-mbstring": "*",
1052 |                 "phpunit/phpunit": "^6.0"
1053 |             },
1054 |             "type": "library",
1055 |             "extra": {
1056 |                 "branch-alias": {
1057 |                     "dev-master": "3.1.x-dev"
1058 |                 }
1059 |             },
1060 |             "autoload": {
1061 |                 "classmap": [
1062 |                     "src/"
1063 |                 ]
1064 |             },
1065 |             "notification-url": "https://packagist.org/downloads/",
1066 |             "license": [
1067 |                 "BSD-3-Clause"
1068 |             ],
1069 |             "authors": [
1070 |                 {
1071 |                     "name": "Jeff Welch",
1072 |                     "email": "whatthejeff@gmail.com"
1073 |                 },
1074 |                 {
1075 |                     "name": "Volker Dusch",
1076 |                     "email": "github@wallbash.com"
1077 |                 },
1078 |                 {
1079 |                     "name": "Bernhard Schussek",
1080 |                     "email": "bschussek@2bepublished.at"
1081 |                 },
1082 |                 {
1083 |                     "name": "Sebastian Bergmann",
1084 |                     "email": "sebastian@phpunit.de"
1085 |                 },
1086 |                 {
1087 |                     "name": "Adam Harvey",
1088 |                     "email": "aharvey@php.net"
1089 |                 }
1090 |             ],
1091 |             "description": "Provides the functionality to export PHP variables for visualization",
1092 |             "homepage": "http://www.github.com/sebastianbergmann/exporter",
1093 |             "keywords": [
1094 |                 "export",
1095 |                 "exporter"
1096 |             ],
1097 |             "time": "2017-04-03T13:19:02+00:00"
1098 |         },
1099 |         {
1100 |             "name": "sebastian/global-state",
1101 |             "version": "2.0.0",
1102 |             "source": {
1103 |                 "type": "git",
1104 |                 "url": "https://github.com/sebastianbergmann/global-state.git",
1105 |                 "reference": "e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4"
1106 |             },
1107 |             "dist": {
1108 |                 "type": "zip",
1109 |                 "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4",
1110 |                 "reference": "e8ba02eed7bbbb9e59e43dedd3dddeff4a56b0c4",
1111 |                 "shasum": ""
1112 |             },
1113 |             "require": {
1114 |                 "php": "^7.0"
1115 |             },
1116 |             "require-dev": {
1117 |                 "phpunit/phpunit": "^6.0"
1118 |             },
1119 |             "suggest": {
1120 |                 "ext-uopz": "*"
1121 |             },
1122 |             "type": "library",
1123 |             "extra": {
1124 |                 "branch-alias": {
1125 |                     "dev-master": "2.0-dev"
1126 |                 }
1127 |             },
1128 |             "autoload": {
1129 |                 "classmap": [
1130 |                     "src/"
1131 |                 ]
1132 |             },
1133 |             "notification-url": "https://packagist.org/downloads/",
1134 |             "license": [
1135 |                 "BSD-3-Clause"
1136 |             ],
1137 |             "authors": [
1138 |                 {
1139 |                     "name": "Sebastian Bergmann",
1140 |                     "email": "sebastian@phpunit.de"
1141 |                 }
1142 |             ],
1143 |             "description": "Snapshotting of global state",
1144 |             "homepage": "http://www.github.com/sebastianbergmann/global-state",
1145 |             "keywords": [
1146 |                 "global state"
1147 |             ],
1148 |             "time": "2017-04-27T15:39:26+00:00"
1149 |         },
1150 |         {
1151 |             "name": "sebastian/object-enumerator",
1152 |             "version": "3.0.3",
1153 |             "source": {
1154 |                 "type": "git",
1155 |                 "url": "https://github.com/sebastianbergmann/object-enumerator.git",
1156 |                 "reference": "7cfd9e65d11ffb5af41198476395774d4c8a84c5"
1157 |             },
1158 |             "dist": {
1159 |                 "type": "zip",
1160 |                 "url": "https://api.github.com/repos/sebastianbergmann/object-enumerator/zipball/7cfd9e65d11ffb5af41198476395774d4c8a84c5",
1161 |                 "reference": "7cfd9e65d11ffb5af41198476395774d4c8a84c5",
1162 |                 "shasum": ""
1163 |             },
1164 |             "require": {
1165 |                 "php": "^7.0",
1166 |                 "sebastian/object-reflector": "^1.1.1",
1167 |                 "sebastian/recursion-context": "^3.0"
1168 |             },
1169 |             "require-dev": {
1170 |                 "phpunit/phpunit": "^6.0"
1171 |             },
1172 |             "type": "library",
1173 |             "extra": {
1174 |                 "branch-alias": {
1175 |                     "dev-master": "3.0.x-dev"
1176 |                 }
1177 |             },
1178 |             "autoload": {
1179 |                 "classmap": [
1180 |                     "src/"
1181 |                 ]
1182 |             },
1183 |             "notification-url": "https://packagist.org/downloads/",
1184 |             "license": [
1185 |                 "BSD-3-Clause"
1186 |             ],
1187 |             "authors": [
1188 |                 {
1189 |                     "name": "Sebastian Bergmann",
1190 |                     "email": "sebastian@phpunit.de"
1191 |                 }
1192 |             ],
1193 |             "description": "Traverses array structures and object graphs to enumerate all referenced objects",
1194 |             "homepage": "https://github.com/sebastianbergmann/object-enumerator/",
1195 |             "time": "2017-08-03T12:35:26+00:00"
1196 |         },
1197 |         {
1198 |             "name": "sebastian/object-reflector",
1199 |             "version": "1.1.1",
1200 |             "source": {
1201 |                 "type": "git",
1202 |                 "url": "https://github.com/sebastianbergmann/object-reflector.git",
1203 |                 "reference": "773f97c67f28de00d397be301821b06708fca0be"
1204 |             },
1205 |             "dist": {
1206 |                 "type": "zip",
1207 |                 "url": "https://api.github.com/repos/sebastianbergmann/object-reflector/zipball/773f97c67f28de00d397be301821b06708fca0be",
1208 |                 "reference": "773f97c67f28de00d397be301821b06708fca0be",
1209 |                 "shasum": ""
1210 |             },
1211 |             "require": {
1212 |                 "php": "^7.0"
1213 |             },
1214 |             "require-dev": {
1215 |                 "phpunit/phpunit": "^6.0"
1216 |             },
1217 |             "type": "library",
1218 |             "extra": {
1219 |                 "branch-alias": {
1220 |                     "dev-master": "1.1-dev"
1221 |                 }
1222 |             },
1223 |             "autoload": {
1224 |                 "classmap": [
1225 |                     "src/"
1226 |                 ]
1227 |             },
1228 |             "notification-url": "https://packagist.org/downloads/",
1229 |             "license": [
1230 |                 "BSD-3-Clause"
1231 |             ],
1232 |             "authors": [
1233 |                 {
1234 |                     "name": "Sebastian Bergmann",
1235 |                     "email": "sebastian@phpunit.de"
1236 |                 }
1237 |             ],
1238 |             "description": "Allows reflection of object attributes, including inherited and non-public ones",
1239 |             "homepage": "https://github.com/sebastianbergmann/object-reflector/",
1240 |             "time": "2017-03-29T09:07:27+00:00"
1241 |         },
1242 |         {
1243 |             "name": "sebastian/recursion-context",
1244 |             "version": "3.0.0",
1245 |             "source": {
1246 |                 "type": "git",
1247 |                 "url": "https://github.com/sebastianbergmann/recursion-context.git",
1248 |                 "reference": "5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8"
1249 |             },
1250 |             "dist": {
1251 |                 "type": "zip",
1252 |                 "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8",
1253 |                 "reference": "5b0cd723502bac3b006cbf3dbf7a1e3fcefe4fa8",
1254 |                 "shasum": ""
1255 |             },
1256 |             "require": {
1257 |                 "php": "^7.0"
1258 |             },
1259 |             "require-dev": {
1260 |                 "phpunit/phpunit": "^6.0"
1261 |             },
1262 |             "type": "library",
1263 |             "extra": {
1264 |                 "branch-alias": {
1265 |                     "dev-master": "3.0.x-dev"
1266 |                 }
1267 |             },
1268 |             "autoload": {
1269 |                 "classmap": [
1270 |                     "src/"
1271 |                 ]
1272 |             },
1273 |             "notification-url": "https://packagist.org/downloads/",
1274 |             "license": [
1275 |                 "BSD-3-Clause"
1276 |             ],
1277 |             "authors": [
1278 |                 {
1279 |                     "name": "Jeff Welch",
1280 |                     "email": "whatthejeff@gmail.com"
1281 |                 },
1282 |                 {
1283 |                     "name": "Sebastian Bergmann",
1284 |                     "email": "sebastian@phpunit.de"
1285 |                 },
1286 |                 {
1287 |                     "name": "Adam Harvey",
1288 |                     "email": "aharvey@php.net"
1289 |                 }
1290 |             ],
1291 |             "description": "Provides functionality to recursively process PHP variables",
1292 |             "homepage": "http://www.github.com/sebastianbergmann/recursion-context",
1293 |             "time": "2017-03-03T06:23:57+00:00"
1294 |         },
1295 |         {
1296 |             "name": "sebastian/resource-operations",
1297 |             "version": "1.0.0",
1298 |             "source": {
1299 |                 "type": "git",
1300 |                 "url": "https://github.com/sebastianbergmann/resource-operations.git",
1301 |                 "reference": "ce990bb21759f94aeafd30209e8cfcdfa8bc3f52"
1302 |             },
1303 |             "dist": {
1304 |                 "type": "zip",
1305 |                 "url": "https://api.github.com/repos/sebastianbergmann/resource-operations/zipball/ce990bb21759f94aeafd30209e8cfcdfa8bc3f52",
1306 |                 "reference": "ce990bb21759f94aeafd30209e8cfcdfa8bc3f52",
1307 |                 "shasum": ""
1308 |             },
1309 |             "require": {
1310 |                 "php": ">=5.6.0"
1311 |             },
1312 |             "type": "library",
1313 |             "extra": {
1314 |                 "branch-alias": {
1315 |                     "dev-master": "1.0.x-dev"
1316 |                 }
1317 |             },
1318 |             "autoload": {
1319 |                 "classmap": [
1320 |                     "src/"
1321 |                 ]
1322 |             },
1323 |             "notification-url": "https://packagist.org/downloads/",
1324 |             "license": [
1325 |                 "BSD-3-Clause"
1326 |             ],
1327 |             "authors": [
1328 |                 {
1329 |                     "name": "Sebastian Bergmann",
1330 |                     "email": "sebastian@phpunit.de"
1331 |                 }
1332 |             ],
1333 |             "description": "Provides a list of PHP built-in functions that operate on resources",
1334 |             "homepage": "https://www.github.com/sebastianbergmann/resource-operations",
1335 |             "time": "2015-07-28T20:34:47+00:00"
1336 |         },
1337 |         {
1338 |             "name": "sebastian/version",
1339 |             "version": "2.0.1",
1340 |             "source": {
1341 |                 "type": "git",
1342 |                 "url": "https://github.com/sebastianbergmann/version.git",
1343 |                 "reference": "99732be0ddb3361e16ad77b68ba41efc8e979019"
1344 |             },
1345 |             "dist": {
1346 |                 "type": "zip",
1347 |                 "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/99732be0ddb3361e16ad77b68ba41efc8e979019",
1348 |                 "reference": "99732be0ddb3361e16ad77b68ba41efc8e979019",
1349 |                 "shasum": ""
1350 |             },
1351 |             "require": {
1352 |                 "php": ">=5.6"
1353 |             },
1354 |             "type": "library",
1355 |             "extra": {
1356 |                 "branch-alias": {
1357 |                     "dev-master": "2.0.x-dev"
1358 |                 }
1359 |             },
1360 |             "autoload": {
1361 |                 "classmap": [
1362 |                     "src/"
1363 |                 ]
1364 |             },
1365 |             "notification-url": "https://packagist.org/downloads/",
1366 |             "license": [
1367 |                 "BSD-3-Clause"
1368 |             ],
1369 |             "authors": [
1370 |                 {
1371 |                     "name": "Sebastian Bergmann",
1372 |                     "email": "sebastian@phpunit.de",
1373 |                     "role": "lead"
1374 |                 }
1375 |             ],
1376 |             "description": "Library that helps with managing the version number of Git-hosted PHP projects",
1377 |             "homepage": "https://github.com/sebastianbergmann/version",
1378 |             "time": "2016-10-03T07:35:21+00:00"
1379 |         },
1380 |         {
1381 |             "name": "theseer/tokenizer",
1382 |             "version": "1.1.0",
1383 |             "source": {
1384 |                 "type": "git",
1385 |                 "url": "https://github.com/theseer/tokenizer.git",
1386 |                 "reference": "cb2f008f3f05af2893a87208fe6a6c4985483f8b"
1387 |             },
1388 |             "dist": {
1389 |                 "type": "zip",
1390 |                 "url": "https://api.github.com/repos/theseer/tokenizer/zipball/cb2f008f3f05af2893a87208fe6a6c4985483f8b",
1391 |                 "reference": "cb2f008f3f05af2893a87208fe6a6c4985483f8b",
1392 |                 "shasum": ""
1393 |             },
1394 |             "require": {
1395 |                 "ext-dom": "*",
1396 |                 "ext-tokenizer": "*",
1397 |                 "ext-xmlwriter": "*",
1398 |                 "php": "^7.0"
1399 |             },
1400 |             "type": "library",
1401 |             "autoload": {
1402 |                 "classmap": [
1403 |                     "src/"
1404 |                 ]
1405 |             },
1406 |             "notification-url": "https://packagist.org/downloads/",
1407 |             "license": [
1408 |                 "BSD-3-Clause"
1409 |             ],
1410 |             "authors": [
1411 |                 {
1412 |                     "name": "Arne Blankerts",
1413 |                     "email": "arne@blankerts.de",
1414 |                     "role": "Developer"
1415 |                 }
1416 |             ],
1417 |             "description": "A small library for converting tokenized PHP source code into XML and potentially other formats",
1418 |             "time": "2017-04-07T12:08:54+00:00"
1419 |         },
1420 |         {
1421 |             "name": "webmozart/assert",
1422 |             "version": "1.3.0",
1423 |             "source": {
1424 |                 "type": "git",
1425 |                 "url": "https://github.com/webmozart/assert.git",
1426 |                 "reference": "0df1908962e7a3071564e857d86874dad1ef204a"
1427 |             },
1428 |             "dist": {
1429 |                 "type": "zip",
1430 |                 "url": "https://api.github.com/repos/webmozart/assert/zipball/0df1908962e7a3071564e857d86874dad1ef204a",
1431 |                 "reference": "0df1908962e7a3071564e857d86874dad1ef204a",
1432 |                 "shasum": ""
1433 |             },
1434 |             "require": {
1435 |                 "php": "^5.3.3 || ^7.0"
1436 |             },
1437 |             "require-dev": {
1438 |                 "phpunit/phpunit": "^4.6",
1439 |                 "sebastian/version": "^1.0.1"
1440 |             },
1441 |             "type": "library",
1442 |             "extra": {
1443 |                 "branch-alias": {
1444 |                     "dev-master": "1.3-dev"
1445 |                 }
1446 |             },
1447 |             "autoload": {
1448 |                 "psr-4": {
1449 |                     "Webmozart\\Assert\\": "src/"
1450 |                 }
1451 |             },
1452 |             "notification-url": "https://packagist.org/downloads/",
1453 |             "license": [
1454 |                 "MIT"
1455 |             ],
1456 |             "authors": [
1457 |                 {
1458 |                     "name": "Bernhard Schussek",
1459 |                     "email": "bschussek@gmail.com"
1460 |                 }
1461 |             ],
1462 |             "description": "Assertions to validate method input/output with nice error messages.",
1463 |             "keywords": [
1464 |                 "assert",
1465 |                 "check",
1466 |                 "validate"
1467 |             ],
1468 |             "time": "2018-01-29T19:49:41+00:00"
1469 |         }
1470 |     ],
1471 |     "aliases": [],
1472 |     "minimum-stability": "stable",
1473 |     "stability-flags": [],
1474 |     "prefer-stable": false,
1475 |     "prefer-lowest": false,
1476 |     "platform": {
1477 |         "php": ">=7.0",
1478 |         "ext-mbstring": "*"
1479 |     },
1480 |     "platform-dev": []
1481 | }
1482 | 


--------------------------------------------------------------------------------