├── .gitignore
├── tests
    ├── bootstrap.php
    ├── Fixture
    │   ├── Collection
    │   │   └── TestCollection.php
    │   └── Mutator
    │   │   └── ChefMutator.php
    ├── Dummy.php
    ├── RegistryTest.php
    ├── CollectionCopyTest.php
    ├── CollectionTest.php
    ├── FunctionsTest.php
    └── UnderscoreTest.php
├── src
    ├── Accessor.php
    ├── Initializer.php
    ├── Mutator
    │   ├── CloneMutator.php
    │   ├── CompactMutator.php
    │   ├── KeysMutator.php
    │   ├── ValuesMutator.php
    │   ├── ThruMutator.php
    │   ├── LastMutator.php
    │   ├── HeadMutator.php
    │   ├── TailMutator.php
    │   ├── InitialMutator.php
    │   ├── UniqMutator.php
    │   ├── FilterMutator.php
    │   ├── MergeMutator.php
    │   ├── FlattenMutator.php
    │   ├── InvokeMutator.php
    │   ├── RejectMutator.php
    │   ├── MapMutator.php
    │   ├── IntersectionMutator.php
    │   ├── GroupByMutator.php
    │   ├── TapMutator.php
    │   ├── WithoutMutator.php
    │   ├── DefaultsMutator.php
    │   ├── ExtendMutator.php
    │   ├── ShuffleMutator.php
    │   ├── ZipMutator.php
    │   ├── PluckMutator.php
    │   ├── WhereMutator.php
    │   ├── DifferenceMutator.php
    │   └── SortByMutator.php
    ├── Accessor
    │   ├── ValueAccessor.php
    │   ├── CollectionAccessor.php
    │   ├── ToArrayAccessor.php
    │   ├── MaxAccessor.php
    │   ├── MinAccessor.php
    │   ├── HasAccessor.php
    │   ├── SizeAccessor.php
    │   ├── IndexOfAccessor.php
    │   ├── LastIndexOfAccessor.php
    │   ├── ContainsAccessor.php
    │   ├── ReduceAccessor.php
    │   ├── AllAccessor.php
    │   ├── ReduceRightAccessor.php
    │   ├── FindAccessor.php
    │   └── AnyAccessor.php
    ├── Mutator.php
    ├── Initializer
    │   ├── FromInitializer.php
    │   ├── TimesInitializer.php
    │   └── RangeInitializer.php
    ├── Collection.php
    ├── Registry.php
    ├── Underscore.php
    └── Functions.php
├── .travis.yml
├── .scrutinizer.yml
├── composer.json
├── LICENSE
├── phpunit.xml.dist
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | /.idea/
2 | /vendor/
3 | composer.lock
4 | /tests/coverage/
5 | /build/
6 | 


--------------------------------------------------------------------------------
/tests/bootstrap.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | $loader = require __DIR__ . '/../vendor/autoload.php';
4 | 


--------------------------------------------------------------------------------
/src/Accessor.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Underscore;
4 | 
5 | abstract class Accessor
6 | {
7 | 
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Initializer.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Underscore;
4 | 
5 | abstract class Initializer
6 | {
7 | 
8 | }
9 | 


--------------------------------------------------------------------------------
/tests/Fixture/Collection/TestCollection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Test\Fixture\Collection;
 4 | 
 5 | use Underscore\Collection;
 6 | 
 7 | /**
 8 |  * @codeCoverageIgnore
 9 |  */
10 | class TestCollection extends Collection
11 | {
12 | }
13 | 


--------------------------------------------------------------------------------
/tests/Dummy.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Test;
 4 | 
 5 | class Dummy
 6 | {
 7 |     public $name = 'dummy';
 8 |     public $answer = 42;
 9 |     protected $precious = 'the ring';
10 | 
11 |     /**
12 |      * @return string
13 |      */
14 |     public function getFoo()
15 |     {
16 |         return 'foo';
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/tests/Fixture/Mutator/ChefMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Test\Fixture\Mutator;
 4 | 
 5 | use Underscore\Mutator;
 6 | 
 7 | /**
 8 |  * @codeCoverageIgnore
 9 |  */
10 | class ChefMutator extends Mutator
11 | {
12 |     public function __invoke($collection)
13 |     {
14 |         $collection = clone $collection;
15 |         $collection['chef'] = 'Bork! Bork! Bork!';
16 | 
17 |         return $collection;
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/src/Mutator/CloneMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class CloneMutator extends Mutator
 9 | {
10 |     /**
11 |      * Makes clone of collection
12 |      *
13 |      * @param Collection $collection
14 |      * @return Collection
15 |      */
16 |     public function __invoke($collection)
17 |     {
18 |         return clone $collection;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Accessor/ValueAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class ValueAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Returns wrapped object
12 |      *
13 |      * @param Collection $collection
14 |      * @return mixed
15 |      */
16 |     public function __invoke(Collection $collection)
17 |     {
18 |         return $collection->value();
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Accessor/CollectionAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class CollectionAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Returns a copy of the collection
12 |      *
13 |      * @param Collection $collection
14 |      * @return mixed
15 |      */
16 |     public function __invoke(Collection $collection)
17 |     {
18 |         return clone $collection;
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Accessor/ToArrayAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class ToArrayAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Returns wrapped object as an array
12 |      *
13 |      * @param Collection $collection
14 |      * @return mixed
15 |      */
16 |     public function __invoke(Collection $collection)
17 |     {
18 |         return $collection->toArray();
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |     - 5.4
 5 |     - 5.5
 6 |     - 5.6
 7 |     - 7.0
 8 |     - hhvm
 9 | 
10 | matrix:
11 |     fast_finish: true
12 | 
13 | install:
14 |     - composer install --prefer-source
15 | 
16 | after_script:
17 |     - bash -c '[[ -f "build/clover.xml" ]] && wget https://scrutinizer-ci.com/ocular.phar'
18 |     - bash -c '[[ -f "build/clover.xml" ]] && php ocular.phar code-coverage:upload --format=php-clover build/clover.xml'
19 | 
20 | sudo: false
21 | 


--------------------------------------------------------------------------------
/src/Accessor/MaxAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class MaxAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Returns the largest value in the collection.
12 |      *
13 |      * @param Collection $collection
14 |      * @return mixed
15 |      */
16 |     public function __invoke(Collection $collection)
17 |     {
18 |         return max($collection->toArray());
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Accessor/MinAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class MinAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Returns the smallest value in the collection.
12 |      *
13 |      * @param Collection $collection
14 |      * @return mixed
15 |      */
16 |     public function __invoke(Collection $collection)
17 |     {
18 |         return min($collection->toArray());
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Accessor/HasAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class HasAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Determine if the given key exists in the collection.
12 |      *
13 |      * @param Collection $collection
14 |      * @param string     $key
15 |      * @return mixed
16 |      */
17 |     public function __invoke(Collection $collection, $key)
18 |     {
19 |         return $collection->offsetExists($key);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore;
 4 | 
 5 | abstract class Mutator
 6 | {
 7 |     /**
 8 |      * Get a copy of a collection with new values.
 9 |      *
10 |      * @param Collection $collection
11 |      * @param array $values
12 |      * @return Collection
13 |      */
14 |     protected function copyCollectionWith(Collection $collection, array $values)
15 |     {
16 |         $collection = clone $collection;
17 | 
18 |         $collection->exchangeArray($values);
19 | 
20 |         return $collection;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Accessor/SizeAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class SizeAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Gets the size of the collection by returning length for arrays or number of enumerable properties for objects.
12 |      *
13 |      * @param Collection $collection
14 |      * @return int
15 |      */
16 |     public function __invoke(Collection $collection)
17 |     {
18 |         return $collection->count();
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/src/Accessor/IndexOfAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class IndexOfAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Returns the key of the given value.
12 |      *
13 |      * @param Collection $collection
14 |      * @return mixed
15 |      */
16 |     public function __invoke(Collection $collection, $value)
17 |     {
18 |         $values = $collection->toArray();
19 |         return array_search($value, $values, true);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mutator/CompactMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Functions;
 7 | use Underscore\Mutator;
 8 | 
 9 | class CompactMutator extends Mutator
10 | {
11 |     /**
12 |      * Removes all falsey values.
13 |      *
14 |      * @param Collection $collection
15 |      * @return Collection
16 |      */
17 |     public function __invoke($collection)
18 |     {
19 |         $filter = new FilterMutator();
20 | 
21 |         return $filter($collection, Functions::nop());
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Mutator/KeysMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class KeysMutator extends Mutator
 9 | {
10 |     /**
11 |      * Creates an collection composed of the enumerable property keys of object.
12 |      *
13 |      * @param Collection $collection
14 |      * @return Collection
15 |      */
16 |     public function __invoke($collection)
17 |     {
18 |         $values = array_keys($collection->toArray());
19 | 
20 |         return $this->copyCollectionWith($collection, $values);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Mutator/ValuesMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class ValuesMutator extends Mutator
 9 | {
10 |     /**
11 |      * Creates an collection composed of the enumerable property values of object.
12 |      *
13 |      * @param Collection $collection
14 |      * @return Collection
15 |      */
16 |     public function __invoke($collection)
17 |     {
18 |         $values = array_values($collection->toArray());
19 | 
20 |         return $this->copyCollectionWith($collection, $values);
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/src/Accessor/LastIndexOfAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class LastIndexOfAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Returns the key of the given value, in the last possible position.
12 |      *
13 |      * @param Collection $collection
14 |      * @return mixed
15 |      */
16 |     public function __invoke(Collection $collection, $value)
17 |     {
18 |         $values = array_reverse($collection->toArray(), true);
19 |         return array_search($value, $values, true);
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Mutator/ThruMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class ThruMutator extends Mutator
 9 | {
10 |     /**
11 |      * Allows applying some operator to entire collection at once and returning it's result
12 |      *
13 |      * @param Collection $collection
14 |      * @param callable   $iterator
15 |      * @return Collection
16 |      */
17 |     public function __invoke($collection, $iterator)
18 |     {
19 |         $values = call_user_func($iterator, $collection->toArray());
20 | 
21 |         return $this->copyCollectionWith($collection, $values);
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/src/Mutator/LastMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class LastMutator extends Mutator
 9 | {
10 |     /**
11 |      * Gets the last element or last n elements of collection.
12 |      *
13 |      * Returns mixed[]
14 |      *
15 |      * @param Collection $collection
16 |      * @param int        $count
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $count = 1)
20 |     {
21 |         $values = array_slice($collection->toArray(), -$count);
22 | 
23 |         return $this->copyCollectionWith($collection, $values);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Mutator/HeadMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class HeadMutator extends Mutator
 9 | {
10 |     /**
11 |      * Gets the first element or first n elements of collection.
12 |      *
13 |      * Returns mixed[]
14 |      *
15 |      * @param Collection $collection
16 |      * @param int        $count
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $count = 1)
20 |     {
21 |         $values = array_slice($collection->toArray(), 0, $count);
22 | 
23 |         return $this->copyCollectionWith($collection, $values);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Mutator/TailMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class TailMutator extends Mutator
 9 | {
10 |     /**
11 |      * Gets all but the first element or first n elements of collection.
12 |      *
13 |      * Returns mixed[]
14 |      *
15 |      * @param Collection $collection
16 |      * @param int        $count
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $count = 1)
20 |     {
21 |         $values = array_slice($collection->toArray(), $count);
22 | 
23 |         return $this->copyCollectionWith($collection, $values);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/.scrutinizer.yml:
--------------------------------------------------------------------------------
 1 | imports:
 2 |     - php
 3 | 
 4 | tools:
 5 |     external_code_coverage:
 6 |         timeout: 600
 7 | 
 8 |     php_code_sniffer:       true
 9 | 
10 |     php_cpd:                true
11 | 
12 |     php_cs_fixer:           true
13 | 
14 |     php_mess_detector:      true
15 | 
16 |     php_pdepend:            true
17 | 
18 |     php_loc:                true
19 | 
20 |     php_analyzer:
21 |         config:
22 |             doc_comment_fixes:
23 |                 enabled:    true
24 | 
25 |     sensiolabs_security_checker: true
26 | 
27 | changetracking:
28 |     bug_patterns: ["\bfix(?:es|ed)?\b"]
29 |     feature_patterns: ["\badd(?:s|ed)?\b", "\bimplement(?:s|ed)?\b"]
30 | 


--------------------------------------------------------------------------------
/src/Mutator/InitialMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class InitialMutator extends Mutator
 9 | {
10 |     /**
11 |      * Gets all but the last element or last n elements of collection.
12 |      *
13 |      * Returns mixed[]
14 |      *
15 |      * @param Collection $collection
16 |      * @param int        $count
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $count = 1)
20 |     {
21 |         $values = array_slice($collection->toArray(), 0, -$count);
22 | 
23 |         return $this->copyCollectionWith($collection, $values);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/src/Mutator/UniqMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class UniqMutator extends Mutator
 9 | {
10 |     /**
11 |      * Removes duplicate items from the collection.
12 |      *
13 |      * @param Collection $collection
14 |      * @return Collection
15 |      */
16 |     public function __invoke($collection)
17 |     {
18 |         $seen = [];
19 |         foreach ($collection as $k => $v) {
20 |             if (!in_array($v, $seen, true)) {
21 |                 $seen[$k] = $v;
22 |             }
23 |         }
24 | 
25 |         return $this->copyCollectionWith($collection, $seen);
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Mutator/FilterMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class FilterMutator extends Mutator
 9 | {
10 |     /**
11 |      * Iterates over elements of a collection, returning an array of all elements the callback returns truey for.
12 |      *
13 |      * @param Collection $collection
14 |      * @param callable   $iterator
15 |      * @return Collection
16 |      */
17 |     public function __invoke($collection, $iterator)
18 |     {
19 |         return $this->copyCollectionWith($collection, array_filter(
20 |             $collection->toArray(),
21 |             $iterator
22 |         ));
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Mutator/MergeMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class MergeMutator extends Mutator
 9 | {
10 |     /**
11 |      * Merges two collections. If keys collide, new value overwrites older.
12 |      *
13 |      * @param Collection $collection
14 |      * @param \Iterator  $values
15 |      * @return Collection
16 |      */
17 |     public function __invoke($collection, $values)
18 |     {
19 |         $collection = clone $collection;
20 | 
21 |         foreach ($values as $key => $value) {
22 |             $collection[$key] = $value;
23 |         }
24 | 
25 |         return $collection;
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Initializer/FromInitializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Initializer;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Initializer;
 7 | use Underscore\Underscore;
 8 | 
 9 | class FromInitializer extends Initializer
10 | {
11 |     /**
12 |      * Initializes Underscore object and sets argument as internal collection
13 |      *
14 |      * @param mixed $item
15 |      * @return Underscore
16 |      */
17 |     public function __invoke($item)
18 |     {
19 |         if ($item instanceof Collection) {
20 |             $item = clone $item;
21 |         } else {
22 |             $item = new Collection($item);
23 |         }
24 |         return new Underscore($item);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Mutator/FlattenMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class FlattenMutator extends Mutator
 9 | {
10 |     /**
11 |      * Performs shallow flatten operation on collection (unwraps first level of array)
12 |      *
13 |      * @param Collection $collection
14 |      * @return Collection
15 |      */
16 |     public function __invoke($collection)
17 |     {
18 |         $newCollection = [];
19 | 
20 |         foreach ($collection as $value) {
21 |             $newCollection = array_merge($newCollection, is_array($value) ? $value : [$value]);
22 |         }
23 | 
24 |         return $this->copyCollectionWith($collection, $newCollection);
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Mutator/InvokeMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class InvokeMutator extends Mutator
 9 | {
10 |     /**
11 |      * Call $iterator for each element
12 |      *
13 |      * $iterator = function($value, $key, $collection)
14 |      *
15 |      * @param Collection $collection
16 |      * @param callable   $iterator
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $iterator)
20 |     {
21 |         $collection = clone $collection;
22 |         foreach ($collection as $k => $v) {
23 |             call_user_func($iterator, $v, $k, $collection);
24 |         }
25 | 
26 |         return $collection;
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Mutator/RejectMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class RejectMutator extends Mutator
 9 | {
10 |     /**
11 |      * The opposite of filter(). This mutator returns the elements of a collection that the callback
12 |      * does **not** return truey for.
13 |      *
14 |      * @param Collection $collection
15 |      * @param callable   $iterator
16 |      * @return Collection
17 |      */
18 |     public function __invoke($collection, $iterator)
19 |     {
20 |         $filter = new FilterMutator;
21 | 
22 |         return $filter($collection, function () use ($iterator) {
23 |             return !call_user_func_array($iterator, func_get_args());
24 |         });
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/src/Accessor/ContainsAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class ContainsAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Checks if a given value is present in a collection using strict equality for comparisons.
12 |      *
13 |      * Returns bool
14 |      *
15 |      * @param Collection $collection
16 |      * @param mixed      $needle
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $needle)
20 |     {
21 |         $iterator = function ($value) use ($needle) {
22 |             return $value === $needle;
23 |         };
24 | 
25 |         $find = new FindAccessor();
26 | 
27 |         return $find($collection, $iterator);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Mutator/MapMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class MapMutator extends Mutator
 9 | {
10 |     /**
11 |      * Replaces every element with value returned by individual $iterator call
12 |      *
13 |      * $iterator = function($value, $key, $collection)
14 |      *
15 |      * @param Collection $collection
16 |      * @param callable   $iterator
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $iterator)
20 |     {
21 |         $collection = clone $collection;
22 | 
23 |         foreach ($collection as $k => $v) {
24 |             $collection[$k] = call_user_func($iterator, $v, $k, $collection);
25 |         }
26 | 
27 |         return $collection;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Mutator/IntersectionMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class IntersectionMutator extends Mutator
 9 | {
10 |     /**
11 |      * Intersects two collections.
12 |      *
13 |      * @param Collection $collection
14 |      * @param \Iterator  $values
15 |      * @return Collection
16 |      */
17 |     public function __invoke($collection, $values)
18 |     {
19 |         $collection = clone $collection;
20 | 
21 |         if (!is_array($values)) {
22 |             $values = iterator_to_array($values);
23 |         }
24 | 
25 |         $collection->exchangeArray(array_intersect(
26 |             $collection->getArrayCopy(),
27 |             $values
28 |         ));
29 | 
30 |         return $collection;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name":        "im0rtality/underscore",
 3 |     "description": "Functional programming library for PHP",
 4 |     "license":  "MIT",
 5 |     "authors":  [
 6 |         {
 7 |             "name": "Laurynas Veržukauskas",
 8 |             "homepage": "https://github.com/im0rtality"
 9 |         },
10 |         {
11 |             "name": "Woody Gilk",
12 |             "email": "woody.gilk@gmail.com"
13 |         }
14 |     ],
15 |     "autoload": {
16 |         "psr-4": {
17 |             "Underscore\\": "src/"
18 |         }
19 |     },
20 |     "autoload-dev": {
21 |         "psr-4": {
22 |             "Underscore\\Test\\": "tests/"
23 |         }
24 |     },
25 |     "require":  {
26 |         "php": ">=5.4"
27 |     },
28 |     "require-dev": {
29 |         "phpunit/phpunit": "~4.7"
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Mutator/GroupByMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class GroupByMutator extends Mutator
 9 | {
10 |     /**
11 |      * Creates an object composed of keys generated from the results
12 |      * of running each element of a collection through the callback
13 |      *
14 |      * @param Collection $collection
15 |      * @param callable   $iterator
16 |      * @return Collection
17 |      */
18 |     public function __invoke($collection, $iterator)
19 |     {
20 |         $newCollection = [];
21 | 
22 |         foreach ($collection as $value) {
23 |             $newCollection[call_user_func($iterator, $value)][] = $value;
24 |         }
25 | 
26 |         return $this->copyCollectionWith($collection, $newCollection);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Accessor/ReduceAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class ReduceAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Reduces collection to single value using $iterator
12 |      *
13 |      * $iterator = function($accumulator, $value)
14 |      *
15 |      * @param Collection $collection
16 |      * @param callable   $iterator
17 |      * @param mixed      $initial
18 |      * @return Collection
19 |      */
20 |     public function __invoke($collection, $iterator, $initial = null)
21 |     {
22 |         $collection = clone $collection;
23 | 
24 |         foreach ($collection as $value) {
25 |             $initial = call_user_func($iterator, $initial, $value);
26 |         }
27 | 
28 |         return $initial;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Mutator/TapMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class TapMutator extends Mutator
 9 | {
10 |     /**
11 |      * Invokes $callback with the wrapped value of collection as the first argument
12 |      * and then wraps it back.
13 |      *
14 |      * The purpose of this Mutator
15 |      * is to "tap into" a Mutator
16 |      * chain in order to
17 |      * perform operations on intermediate results within the chain.
18 |      *
19 |      * @param Collection $collection
20 |      * @param callable   $iterator
21 |      * @return Collection
22 |      */
23 |     public function __invoke($collection, $iterator)
24 |     {
25 |         call_user_func($iterator, $collection->toArray());
26 | 
27 |         return $collection;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Accessor/AllAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class AllAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Checks if the $iterator returns a truey value for ALL element of a collection.
12 |      *
13 |      * Returns boolean
14 |      *
15 |      * @param Collection $collection
16 |      * @param callable   $iterator
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $iterator)
20 |     {
21 |         $iterator = function ($accumulator, $item) use ($iterator) {
22 |             $accumulator = $accumulator && $iterator($item);
23 | 
24 |             return $accumulator;
25 |         };
26 | 
27 |         $reduce = new ReduceAccessor();
28 | 
29 |         return $reduce($collection, $iterator, true);
30 |     }
31 | }
32 | 


--------------------------------------------------------------------------------
/src/Mutator/WithoutMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Accessor\ContainsAccessor;
 6 | use Underscore\Collection;
 7 | use Underscore\Mutator;
 8 | 
 9 | class WithoutMutator extends Mutator
10 | {
11 |     /**
12 |      * Removes all provided values using strict comparison.
13 |      *
14 |      * @param Collection   $collection
15 |      * @param \ArrayAccess $values
16 |      * @return Collection
17 |      */
18 |     public function __invoke($collection, $values)
19 |     {
20 |         $values = new Collection($values);
21 |         $contains = new ContainsAccessor();
22 |         $reject = new RejectMutator();
23 | 
24 |         $iterator = function ($item) use ($values, $contains) {
25 |             return $contains($values, $item);
26 |         };
27 | 
28 |         return $reject($collection, $iterator);
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Accessor/ReduceRightAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class ReduceRightAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Reduces collection to single value using $iterator. Reversed direction.
12 |      *
13 |      * $iterator = function($accumulator, $value)
14 |      *
15 |      * @param Collection $collection
16 |      * @param callable   $iterator
17 |      * @param mixed      $initial
18 |      * @return Collection
19 |      */
20 |     public function __invoke($collection, $iterator, $initial = null)
21 |     {
22 |         $collection = clone $collection;
23 | 
24 |         foreach ($collection->getIteratorReversed() as $value) {
25 |             $initial = call_user_func($iterator, $initial, $value);
26 |         }
27 | 
28 |         return $initial;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Accessor/FindAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class FindAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Iterates over elements of a collection, returning the first element that the callback returns truey for.
12 |      *
13 |      * Returns mixed
14 |      *
15 |      * @param Collection $collection
16 |      * @param callable   $iterator
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $iterator)
20 |     {
21 |         $collection = clone $collection;
22 | 
23 |         $found = false;
24 |         foreach ($collection as $k => $v) {
25 |             if (call_user_func($iterator, $v, $k, $collection)) {
26 |                 $found = true;
27 |                 break;
28 |             }
29 |         }
30 | 
31 |         return $found;
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Initializer/TimesInitializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Initializer;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Initializer;
 7 | use Underscore\Underscore;
 8 | 
 9 | class TimesInitializer extends Initializer
10 | {
11 |     /**
12 |      * Invokes the given iteratee function n times.
13 |      *
14 |      * Each invocation of iteratee is called with an index argument. Produces a
15 |      * Collection of the returned values.
16 |      *
17 |      * @param integer  $count
18 |      * @param callable $function
19 |      * @return Underscore
20 |      */
21 |     public function __invoke($count, $function /*, $context */)
22 |     {
23 |         // Context switching is possible in PHP 5.4 by using Closure::bind.
24 | 
25 |         $results = [];
26 |         for ($i = 0; $i < $count; $i++) {
27 |             $results[] = $function($i);
28 |         }
29 | 
30 |         return new Underscore(new Collection($results));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Accessor/AnyAccessor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Accessor;
 4 | 
 5 | use Underscore\Accessor;
 6 | use Underscore\Collection;
 7 | 
 8 | class AnyAccessor extends Accessor
 9 | {
10 |     /**
11 |      * Checks if the $iterator returns a truey value for ANY element of a collection.
12 |      * The function returns as soon as it finds a passing value and does not iterate
13 |      * over entire collection.
14 |      *
15 |      * Returns boolean
16 |      *
17 |      * @param Collection $collection
18 |      * @param callable   $iterator
19 |      * @return Collection
20 |      */
21 |     public function __invoke($collection, $iterator)
22 |     {
23 |         $iterator = function ($accumulator, $item) use ($iterator) {
24 |             $accumulator = $accumulator || $iterator($item);
25 | 
26 |             return $accumulator;
27 |         };
28 | 
29 |         $reduce = new ReduceAccessor();
30 | 
31 |         return $reduce($collection, $iterator, false);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Initializer/RangeInitializer.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Initializer;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Initializer;
 7 | use Underscore\Underscore;
 8 | 
 9 | class RangeInitializer extends Initializer
10 | {
11 |     /**
12 |      * Creates Underscore object containing array of numbers
13 |      *
14 |      * @param int $start Start number, inclusive
15 |      * @param int $stop  Stop number, not inclusive
16 |      * @param int $step  Step size, non-zero, can be negative
17 |      *
18 |      * @throws \LogicException
19 |      * @return Underscore
20 |      */
21 |     public function __invoke($start, $stop, $step = 1)
22 |     {
23 |         if (0 == $step) {
24 |             throw new \LogicException('$step have to be non-zero');
25 |         }
26 | 
27 |         $array = [];
28 | 
29 |         for ($i = (int)$start; $i < (int)$stop; $i += (int)$step) {
30 |             $array[] = $i;
31 |         }
32 | 
33 |         return new Underscore(new Collection($array));
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Mutator/DefaultsMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class DefaultsMutator extends Mutator
 9 | {
10 |     /**
11 |      * Fill in null properties in object.
12 |      *
13 |      * Uses the first value present in any of the defaults.
14 |      *
15 |      * @param Collection $collection
16 |      * @param mixed      $default
17 |      * @param ...
18 |      * @return Collection
19 |      */
20 |     public function __invoke($collection, $default)
21 |     {
22 |         $defaults = func_get_args();
23 |         array_shift($defaults); // remove $collection
24 | 
25 |         $collection = clone $collection;
26 | 
27 |         foreach ($defaults as $default) {
28 |             foreach ($default as $key => $value) {
29 |                 if (!isset($collection[$key])) {
30 |                     $collection[$key] = $value;
31 |                 }
32 |             }
33 |         }
34 | 
35 |         return $collection;
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Mutator/ExtendMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class ExtendMutator extends Mutator
 9 | {
10 |     /**
11 |      * Copy all of the properties in the source objects over to the destination object.
12 |      *
13 |      * It's in-order, so the last source will override properties of the same name
14 |      * in previous arguments.
15 |      *
16 |      * @param Collection $collection
17 |      * @param mixed      $source
18 |      * @param ...
19 |      * @return Collection
20 |      */
21 |     public function __invoke($collection, $source)
22 |     {
23 |         $sources = func_get_args();
24 |         array_shift($sources); // remove $collection
25 | 
26 |         $collection = clone $collection;
27 | 
28 |         foreach ($sources as $source) {
29 |             foreach ($source as $key => $value) {
30 |                 $collection[$key] = $value;
31 |             }
32 |         }
33 | 
34 |         return $collection;
35 |     }
36 | }
37 | 


--------------------------------------------------------------------------------
/src/Mutator/ShuffleMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class ShuffleMutator extends Mutator
 9 | {
10 |     /**
11 |      * Shuffles the values of a collection while preserving the keys.
12 |      *
13 |      * @param Collection $collection
14 |      * @return Collection
15 |      */
16 |     public function __invoke($collection)
17 |     {
18 |         $values = $this->shuffleAssoc($collection->toArray());
19 | 
20 |         return $this->copyCollectionWith($collection, $values);
21 |     }
22 | 
23 |     /**
24 |      * Shuffle an array while preserving keys.
25 |      *
26 |      * @param array $values
27 |      *
28 |      * @return array
29 |      */
30 |     private function shuffleAssoc(array $values)
31 |     {
32 |         $keys = array_keys($values);
33 |         shuffle($keys);
34 | 
35 |         $output = [];
36 |         foreach ($keys as $key) {
37 |             $output[$key] = $values[$key];
38 |         }
39 | 
40 |         return $output;
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/src/Mutator/ZipMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class ZipMutator extends Mutator
 9 | {
10 |     /**
11 |      * Combines current collection values with given keys to produce new collection
12 |      *
13 |      * @param Collection $collection
14 |      * @param mixed[]    $keys
15 |      * @return Collection
16 |      * @throws \LogicException
17 |      */
18 |     public function __invoke($collection, $keys)
19 |     {
20 |         $values = call_user_func(new ValuesMutator, $collection)->toArray();
21 |         $keys = call_user_func(new ValuesMutator, new Collection($keys))->toArray();
22 | 
23 |         if (count($values) !== count($keys)) {
24 |             throw new \LogicException('Keys and values count must match');
25 |         }
26 | 
27 |         $newCollection = [];
28 | 
29 |         foreach ($values as $index => $value) {
30 |             $newCollection[$keys[$index]] = $value;
31 |         }
32 | 
33 |         return $this->copyCollectionWith($collection, $newCollection);
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/src/Collection.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore;
 4 | 
 5 | class Collection extends \ArrayObject
 6 | {
 7 |     public function __construct($input)
 8 |     {
 9 |         if (is_object($input)) {
10 |             if ($input instanceof \Traversable) {
11 |                 $input = iterator_to_array($input);
12 |             } else {
13 |                 $input = get_object_vars($input);
14 |             }
15 |         }
16 |         parent::__construct($input, static::ARRAY_AS_PROPS);
17 |     }
18 | 
19 |     /**
20 |      * @return \ArrayIterator
21 |      */
22 |     public function getIteratorReversed()
23 |     {
24 |         $iterator = $this->getIteratorClass();
25 |         $collection = array_reverse($this->getArrayCopy());
26 | 
27 |         return new $iterator($collection);
28 |     }
29 | 
30 |     /**
31 |      * @return mixed
32 |      */
33 |     public function value()
34 |     {
35 |         return $this->toArray();
36 |     }
37 | 
38 |     /**
39 |      * @return mixed[]
40 |      */
41 |     public function toArray()
42 |     {
43 |         return $this->getArrayCopy();
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/src/Mutator/PluckMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class PluckMutator extends Mutator
 9 | {
10 |     /**
11 |      * Serves as shorthand to get list of specific key value from every element
12 |      *
13 |      * If key not found returns null
14 |      *
15 |      * @param Collection $collection
16 |      * @param string|int $key
17 |      * @return Collection
18 |      */
19 |     public function __invoke($collection, $key)
20 |     {
21 |         $iterator = function ($value) use ($key) {
22 |             if (is_object($value)) {
23 |                 if (is_callable([$value, $key])) {
24 |                     return call_user_func([$value, $key]);
25 |                 } else {
26 |                     return isset($value->{$key}) ? $value->{$key} : null;
27 |                 }
28 |             } else {
29 |                 return isset($value[$key]) ? $value[$key] : null;
30 |             }
31 |         };
32 | 
33 |         $map = new MapMutator();
34 | 
35 |         return $map($collection, $iterator);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/src/Mutator/WhereMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class WhereMutator extends Mutator
 9 | {
10 |     /**
11 |      * Remove all values that do not match the given key-value pairs.
12 |      *
13 |      * By default strict comparison is used.
14 |      *
15 |      * @param Collection $collection
16 |      * @param array      $properties
17 |      * @param boolean    $strict
18 |      * @return Collection
19 |      */
20 |     public function __invoke($collection, array $properties, $strict = true)
21 |     {
22 |         $filter = new FilterMutator;
23 | 
24 |         return $filter($collection, function ($item) use ($properties, $strict) {
25 |             foreach ($properties as $key => $value) {
26 |                 if (empty($item[$key])
27 |                     || ($strict && $item[$key] !== $value)
28 |                     || (!$strict && $item[$key] != $value)
29 |                 ) {
30 |                     return false;
31 |                 }
32 |             }
33 | 
34 |             return true;
35 |         });
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Laurynas Veržukauskas
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/phpunit.xml.dist:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 |     <phpunit backupGlobals="false"
 3 |              backupStaticAttributes="false"
 4 |              colors="true"
 5 |              convertErrorsToExceptions="true"
 6 |              convertNoticesToExceptions="true"
 7 |              convertWarningsToExceptions="true"
 8 |              processIsolation="false"
 9 |              stopOnFailure="false"
10 |              syntaxCheck="false"
11 |              bootstrap="tests/bootstrap.php">
12 |         <logging>
13 |             <log type="coverage-clover" target="build/clover.xml"/>
14 |             <log type="coverage-html" target="build/" addUncoveredFilesFromWhitelist="true"/>
15 |             <log type="coverage-text" target="php://stdout" showOnlySummary="true"/>
16 |         </logging>
17 | 
18 |         <filter>
19 |             <whitelist>
20 |                 <directory>./src</directory>
21 |                 <exclude>
22 |                     <directory>./tests/Underscore/Test/Fixture</directory>
23 |                 </exclude>
24 |             </whitelist>
25 |         </filter>
26 | 
27 |         <testsuites>
28 |             <testsuite name="Tests">
29 |                 <directory>./tests/</directory>
30 |             </testsuite>
31 |         </testsuites>
32 | </phpunit>
33 | 


--------------------------------------------------------------------------------
/src/Mutator/DifferenceMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class DifferenceMutator extends Mutator
 9 | {
10 |     /**
11 |      * Finds the difference of two collections.
12 |      *
13 |      * @param Collection $collection
14 |      * @param \Iterator  $values
15 |      * @return Collection
16 |      */
17 |     public function __invoke($collection, $values)
18 |     {
19 |         $collection = clone $collection;
20 | 
21 |         if (!is_array($values)) {
22 |             $values = iterator_to_array($values);
23 |         }
24 | 
25 |         $current = $collection->getArrayCopy();
26 | 
27 |         if ($this->isAssoc($current)) {
28 |             $values = array_diff_assoc($current, $values);
29 |         } else {
30 |             $values = array_diff($current, $values);
31 |         }
32 | 
33 |         $collection->exchangeArray($values);
34 | 
35 |         return $collection;
36 |     }
37 | 
38 |     /**
39 |      * Check if an array is associative.
40 |      *
41 |      * @param array $values
42 |      *
43 |      * @return boolean
44 |      */
45 |     private function isAssoc(array $values)
46 |     {
47 |         $keys = array_keys($values);
48 |         return $keys !== array_keys($keys);
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Mutator/SortByMutator.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Mutator;
 4 | 
 5 | use Underscore\Collection;
 6 | use Underscore\Mutator;
 7 | 
 8 | class SortByMutator extends Mutator
 9 | {
10 |     /**
11 |      * Creates an array of elements, sorted in ascending order by the results
12 |      * of running each element in a collection through the callback
13 |      *
14 |      * When values returned by $callback are equal the order is undefined (i.e. the sort is not stable)
15 |      *
16 |      * @param Collection $collection
17 |      * @param callable   $iterator
18 |      * @return Collection
19 |      */
20 |     public function __invoke($collection, $iterator)
21 |     {
22 |         $sortFunc = function ($value) {
23 |             sort($value);
24 | 
25 |             return $value;
26 |         };
27 | 
28 |         /** @var $collection Collection */
29 |         $collection = call_user_func(new GroupByMutator(), $collection, $iterator);
30 | 
31 |         // read once - for performance
32 |         $val = $collection->value();
33 | 
34 |         $mapFunc = function ($key) use ($val) {
35 |             return $val[$key];
36 |         };
37 | 
38 |         $collection = call_user_func(new KeysMutator(), $collection);
39 |         $collection = call_user_func(new ThruMutator(), $collection, $sortFunc);
40 |         $collection = call_user_func(new MapMutator(), $collection, $mapFunc);
41 |         $collection = call_user_func(new FlattenMutator(), $collection);
42 | 
43 |         return $collection;
44 |     }
45 | }
46 | 


--------------------------------------------------------------------------------
/tests/RegistryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Underscore\Test;
 4 | 
 5 | use Underscore\Registry;
 6 | 
 7 | class RegistryTest extends \PHPUnit_Framework_TestCase
 8 | {
 9 |     public function testDefault()
10 |     {
11 |         $registry = new Registry();
12 | 
13 |         $this->assertInstanceOf('Underscore\Accessor\ValueAccessor', $registry->instance('value'));
14 |         $this->assertInstanceOf('Underscore\Initializer\FromInitializer', $registry->instance('from'));
15 |         $this->assertInstanceOf('Underscore\Mutator\LastMutator', $registry->instance('last'));
16 |     }
17 | 
18 |     public function testConstructorAlias()
19 |     {
20 |         $registry = new Registry([
21 |             'last' => 'Underscore\Test\Fixture\Mutator\ChefMutator',
22 |         ]);
23 | 
24 |         $this->assertInstanceOf('Underscore\Test\Fixture\Mutator\ChefMutator', $registry->instance('last'));
25 |     }
26 | 
27 |     public function testAliasSpec()
28 |     {
29 |         $registry = new Registry();
30 | 
31 |         $this->assertInstanceOf('Underscore\Mutator\LastMutator', $registry->instance('last'));
32 | 
33 |         $registry->alias('last', 'Underscore\Test\Fixture\Mutator\ChefMutator');
34 | 
35 |         $this->assertInstanceOf('Underscore\Test\Fixture\Mutator\ChefMutator', $registry->instance('last'));
36 |     }
37 | 
38 |     public function testAliasConcrete()
39 |     {
40 |         $registry = new Registry();
41 | 
42 |         $accessor = function ($collection) {
43 |         };
44 | 
45 |         $registry->alias('fin', $accessor);
46 | 
47 |         $this->assertSame($accessor, $registry->instance('fin'));
48 |     }
49 | 
50 |     /**
51 |      * @expectedException BadMethodCallException
52 |      */
53 |     public function testMissingInstance()
54 |     {
55 |         $registry = new Registry();
56 | 
57 |         $registry->instance('invalid');
58 |     }
59 | }
60 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Underscore
 2 | 
 3 | [![Build Status](https://travis-ci.org/Im0rtality/Underscore.svg?branch=master)](https://travis-ci.org/Im0rtality/Underscore)
 4 | [![Scrutinizer Quality Score](https://scrutinizer-ci.com/g/Im0rtality/Underscore/badges/quality-score.png?s=a360715f49ea4bba225b7991146981ca80b61337)](https://scrutinizer-ci.com/g/Im0rtality/Underscore/)
 5 | [![Code Coverage](https://scrutinizer-ci.com/g/Im0rtality/Underscore/badges/coverage.png?s=e9c5669f300b4d8cb96d0fa8645119ab546fbd62)](https://scrutinizer-ci.com/g/Im0rtality/Underscore/)
 6 | [![SensioLabsInsight](https://insight.sensiolabs.com/projects/d7ef44af-707d-4638-b91e-8fd043dc99e0/mini.png)](https://insight.sensiolabs.com/projects/d7ef44af-707d-4638-b91e-8fd043dc99e0)
 7 | 
 8 | Functional programming library for PHP
 9 | 
10 | # Code example
11 | 
12 | Library aims to be as easy to use as possible. Here is example of doing some not-so-meaningful operations to show off:
13 | 
14 | ```php
15 |     Underscore::from([1,2,3,4,5])
16 |             // convert array format
17 |         ->map(function($num) { return ['number' => $num];})
18 |             // filter out odd elements
19 |         ->filter(function($item) { return ($item['number'] % 2) == 0;})
20 |             // vardump elements
21 |         ->invoke(function($item) { var_dump($item);})
22 |             // changed my mind, I only want numbers
23 |         ->pick('number')
24 |             // add numbers to 1000
25 |         ->reduce(function($sum, $num) { $sum += $num; return $sum; }, 1000)
26 |             // take result
27 |         ->value();
28 |             // 1006
29 | ```
30 | 
31 | # Motivation
32 | 
33 | Originaly I needed functional programming magic for other project, so had to pick one lib or write my own.
34 | 
35 | There is several PHP ports of UnderscoreJS, however none of those fit my requirements (nice code, easy to write, standardized):
36 |  - [brianhaveri/Underscore.php](https://github.com/brianhaveri/Underscore.php) - not maintained, messy code
37 |  - [Anahkiasen/underscore-php](https://github.com/Anahkiasen/underscore-php) - Laravel4 package => incompatible with PSR-2
38 | 
39 | # Installation
40 | 
41 | Via composer:
42 | 
43 |     $ composer require im0rtality/underscore:*
44 | 
45 | Composer docs recommend to use specific version. You can look them up in [Releases](https://github.com/Im0rtality/Underscore/releases).
46 | 
47 | # Documentation
48 | 
49 | See [wiki](https://github.com/Im0rtality/Underscore/wiki/Intro)
50 | 
51 | # Tests
52 | 
53 | Tests generate coverage reports in clover.xml format
54 | 
55 |     $ vendor/bin/phpunit
56 | 
57 | # License
58 | 
59 | MIT License: You can do whatever you want as long as you include the original copyright.
60 | 


--------------------------------------------------------------------------------
/tests/CollectionCopyTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Underscore\Test;
  4 | 
  5 | use Underscore\Underscore;
  6 | use Underscore\Test\Fixture\Collection\TestCollection;
  7 | 
  8 | class CollectionCopyTest extends \PHPUnit_Framework_TestCase
  9 | {
 10 |     public function dataMutate()
 11 |     {
 12 |         return [
 13 |             [
 14 |                 'Underscore\Mutator\FilterMutator',
 15 |                 function ($value) {
 16 |                     return true;
 17 |                 },
 18 |             ],
 19 |             [
 20 |                 'Underscore\Mutator\FlattenMutator',
 21 |             ],
 22 |             [
 23 |                 'Underscore\Mutator\GroupByMutator',
 24 |                 function ($value) {
 25 |                     return $value;
 26 |                 },
 27 |             ],
 28 |             [
 29 |                 'Underscore\Mutator\HeadMutator',
 30 |             ],
 31 |             [
 32 |                 'Underscore\Mutator\InitialMutator',
 33 |             ],
 34 |             [
 35 |                 'Underscore\Mutator\KeysMutator',
 36 |             ],
 37 |             [
 38 |                 'Underscore\Mutator\LastMutator',
 39 |             ],
 40 |             [
 41 |                 'Underscore\Mutator\TailMutator',
 42 |             ],
 43 |             [
 44 |                 'Underscore\Mutator\ThruMutator',
 45 |                 function ($values) {
 46 |                     return $values;
 47 |                 },
 48 |             ],
 49 |             [
 50 |                 'Underscore\Mutator\ZipMutator',
 51 |                 [],
 52 |             ],
 53 |         ];
 54 |     }
 55 | 
 56 |     /**
 57 |      * @dataProvider dataMutate
 58 |      */
 59 |     public function testMutate($mutator)
 60 |     {
 61 |         // Get all arguments for the mutator
 62 |         $args = func_get_args();
 63 | 
 64 |         // Create the mutator class from the first argument
 65 |         $mutator = array_shift($args);
 66 |         $mutator = new $mutator;
 67 | 
 68 |         // Create a new (empty) collection
 69 |         $collection = new TestCollection([]);
 70 | 
 71 |         // Set the first argument to be the collection
 72 |         array_unshift($args, $collection);
 73 | 
 74 |         // Call the mutator to create a new collection
 75 |         $modified = call_user_func_array($mutator, $args);
 76 | 
 77 |         // The collection should not be the same
 78 |         $this->assertNotSame($collection, $modified);
 79 | 
 80 |         // But should be the same type
 81 |         $this->assertInstanceOf(get_class($collection), $modified);
 82 |     }
 83 | 
 84 |     public function testWrapAndUnwrap()
 85 |     {
 86 |         $collection = new TestCollection([
 87 |             'a', 'b', 'c'
 88 |         ]);
 89 | 
 90 |         // Wrap and unwrap the collection
 91 |         $unwrapped = Underscore::from($collection)->collection();
 92 | 
 93 |         // The collection should a clone
 94 |         $this->assertNotSame($collection, $unwrapped);
 95 | 
 96 |         // But should be the same type
 97 |         $this->assertInstanceOf(get_class($collection), $unwrapped);
 98 | 
 99 |         // And have the same values
100 |         $this->assertSame($collection->toArray(), $unwrapped->toArray());
101 |     }
102 | }
103 | 


--------------------------------------------------------------------------------
/src/Registry.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Underscore;
  4 | 
  5 | /**
  6 |  * Callable registry for Underscore methods.
  7 |  *
  8 |  * It is assumed that all callables will be classes with an `__invoke` method.
  9 |  *
 10 |  * Existing methods can be overloaded by setting an alias of the same name:
 11 |  *
 12 |  *     $registry->alias('keys', 'Acme\KeysMutator');
 13 |  *
 14 |  * New methods can be added in the same way:
 15 |  *
 16 |  *     $registry->alias('fancy', 'Acme\FancyInitializer');
 17 |  *
 18 |  * Every alias is a singleton and will only be created once! If your callable
 19 |  * requires construction, alias a fully constructed object instead:
 20 |  *
 21 |  *     $registry->alias('fancy', new FancyInitializer($parameters));
 22 |  *
 23 |  * NOTE: Mutators, accessors, and initializers all use the same registery and
 24 |  * differ only in how they are used internally by Underscore.
 25 |  */
 26 | class Registry
 27 | {
 28 |     /**
 29 |      * @var array Classes aliased by name of method.
 30 |      */
 31 |     private $aliases = [];
 32 | 
 33 |     /**
 34 |      * @var array Callable instances aliased by name of method.
 35 |      */
 36 |     private $instances = [];
 37 | 
 38 |     /**
 39 |      * @param array $aliases
 40 |      */
 41 |     public function __construct(array $aliases = [])
 42 |     {
 43 |         $this->aliases = $aliases;
 44 |     }
 45 | 
 46 |     /**
 47 |      * Get the callable for an Underscore method alias.
 48 |      *
 49 |      * @param  string $name
 50 |      * @return callable
 51 |      */
 52 |     public function instance($name)
 53 |     {
 54 |         if (empty($this->instances[$name])) {
 55 |             if (empty($this->aliases[$name])) {
 56 |                 $this->aliasDefault($name);
 57 |             }
 58 |             $this->instances[$name] = new $this->aliases[$name];
 59 |         }
 60 | 
 61 |         return $this->instances[$name];
 62 |     }
 63 | 
 64 |     /**
 65 |      * Alias method name to a callable.
 66 |      *
 67 |      * @param  string   $name
 68 |      * @param  callable $spec
 69 |      * @return void
 70 |      */
 71 |     public function alias($name, $spec)
 72 |     {
 73 |         if (is_callable($spec)) {
 74 |             $this->instances[$name] = $spec;
 75 |         } else {
 76 |             $this->aliases[$name] = $spec;
 77 | 
 78 |             // Ensure that the new alias will be used when called.
 79 |             unset($this->instances[$name]);
 80 |         }
 81 |     }
 82 | 
 83 |     /**
 84 |      * Define a default mutator, accessor, or initializer for a method name.
 85 |      *
 86 |      * @throws \BadMethodCallException If no default can be located.
 87 |      * @param  string $name
 88 |      * @return void
 89 |      */
 90 |     private function aliasDefault($name)
 91 |     {
 92 |         $spec = sprintf('\Underscore\Mutator\%sMutator', ucfirst($name));
 93 | 
 94 |         if (!class_exists($spec)) {
 95 |             $spec = sprintf('\Underscore\Accessor\%sAccessor', ucfirst($name));
 96 |         }
 97 | 
 98 |         if (!class_exists($spec)) {
 99 |             $spec = sprintf('\Underscore\Initializer\%sInitializer', ucfirst($name));
100 |         }
101 | 
102 |         if (!class_exists($spec)) {
103 |             throw new \BadMethodCallException(sprintf('Unknown method Underscore->%s()', $name));
104 |         }
105 | 
106 |         $this->aliases[$name] = $spec;
107 |     }
108 | }
109 | 


--------------------------------------------------------------------------------
/tests/CollectionTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Underscore\Test;
  4 | 
  5 | use Underscore\Collection;
  6 | 
  7 | class CollectionTest extends \PHPUnit_Framework_TestCase
  8 | {
  9 | 
 10 |     /**
 11 |      * @return array
 12 |      */
 13 |     public function getTestCollectionData()
 14 |     {
 15 |         $dummy = new Dummy();
 16 |         $data = [];
 17 |         // case #0
 18 |         $data[] = [$dummy];
 19 |         // case #1
 20 |         $data[] = [get_object_vars($dummy)];
 21 | 
 22 |         return $data;
 23 |     }
 24 | 
 25 |     /**
 26 |      * @dataProvider getTestCollectionData
 27 |      */
 28 |     public function testCollection($item)
 29 |     {
 30 |         $collection = new Collection($item);
 31 | 
 32 |         // count
 33 |         $this->assertSame(2, $collection->count());
 34 |         // ArrayAccess test
 35 | 
 36 |         // isset
 37 |         $this->assertTrue(isset($collection['name']));
 38 |         $this->assertFalse(isset($collection['precious']));
 39 |         $this->assertFalse(isset($collection['foo']));
 40 |         // get
 41 |         $this->assertSame('dummy', $collection['name']);
 42 |         $this->assertSame(42, $collection['answer']);
 43 |         // set
 44 |         $collection['foo'] = 'bar';
 45 |         $this->assertTrue(isset($collection['foo']));
 46 |         $this->assertSame('bar', $collection['foo']);
 47 |         $this->assertSame(3, $collection->count());
 48 |         // unset
 49 |         unset($collection['foo']);
 50 |         $this->assertFalse(isset($collection['foo']));
 51 |         $this->assertSame(2, $collection->count());
 52 | 
 53 |         // Iterator test
 54 |         $this->assertInstanceOf('\Traversable', $collection->getIterator());
 55 | 
 56 |         $out = [];
 57 |         foreach ($collection as $key => $value) {
 58 |             $out[$key] = $value;
 59 |         }
 60 |         $this->assertSame(['name' => 'dummy', 'answer' => 42], $out);
 61 | 
 62 |         // Reversed iterator test
 63 |         $this->assertInstanceOf('\Traversable', $collection->getIteratorReversed());
 64 | 
 65 |         $out = [];
 66 |         foreach ($collection->getIteratorReversed() as $key => $value) {
 67 |             $out[$key] = $value;
 68 |         }
 69 |         $this->assertSame(['answer' => 42, 'name' => 'dummy'], $out);
 70 | 
 71 |         // toArray & value
 72 |         $this->assertSame(['name' => 'dummy', 'answer' => 42], $collection->toArray());
 73 |         $this->assertSame($collection->toArray(), $collection->value());
 74 | 
 75 |         $collection['foo'] = 'baz';
 76 |         // here we have one extra key-value pair
 77 |         $this->assertSame(['name' => 'dummy', 'answer' => 42, 'foo' => 'baz'], $collection->toArray());
 78 | 
 79 |         // collection wrapping
 80 |         $wrapped = new Collection($collection);
 81 |         $this->assertSame($collection->toArray(), $wrapped->toArray());
 82 |     }
 83 | 
 84 |     /**
 85 |      * @dataProvider getTestCollectionData
 86 |      */
 87 |     public function testSetValueOnNullKey($item)
 88 |     {
 89 |         $collection = new Collection($item);
 90 |         /** @var $collection Collection */
 91 | 
 92 |         $this->assertEquals(2, $collection->count());
 93 | 
 94 |         $collection[] = 'foo';
 95 |         $this->assertEquals(3, $collection->count());
 96 | 
 97 |         // test finding next free numeric key
 98 |         $collection[] = 'foo';
 99 |         $this->assertEquals(4, $collection->count());
100 |     }
101 | 
102 |     /**
103 |      * @return array
104 |      */
105 |     public function getTestCloneData()
106 |     {
107 |         $json = '{"foo":"bar", "baz":"qux"}';
108 |         $out = [];
109 |         // case #0
110 |         $out[] = [
111 |             json_decode($json, true),
112 |         ];
113 | 
114 |         return $out;
115 |     }
116 | 
117 |     /**
118 |      * @dataProvider getTestCloneData
119 |      */
120 |     public function testClone($clonee)
121 |     {
122 |         $result = new Collection($clonee);
123 | 
124 |         $clone = clone $result;
125 | 
126 |         $value = $clone->value();
127 | 
128 |         $this->assertEquals($clonee, $value);
129 |     }
130 | }
131 | 


--------------------------------------------------------------------------------
/tests/FunctionsTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Underscore\Test;
  4 | 
  5 | use Underscore\Functions;
  6 | 
  7 | class FunctionsTest extends \PHPUnit_Framework_TestCase
  8 | {
  9 |     public function testMemoize()
 10 |     {
 11 |         $counter = 0;
 12 | 
 13 |         $payload = function () use (&$counter) {
 14 |             ++$counter;
 15 |         };
 16 | 
 17 |         $memoized = Functions::memoize($payload);
 18 | 
 19 |         $memoized();
 20 |         $memoized();
 21 |         $memoized();
 22 |         $memoized();
 23 |         $memoized();
 24 | 
 25 |         $this->assertEquals(1, $counter);
 26 |     }
 27 | 
 28 |     public function testNop()
 29 |     {
 30 |         $nop = Functions::nop();
 31 | 
 32 |         $ref = new \stdClass();
 33 | 
 34 |         $this->assertSame($ref, $nop($ref));
 35 |     }
 36 | 
 37 |     public function testOnce()
 38 |     {
 39 |         $counter = 0;
 40 | 
 41 |         $initialize = Functions::once(function () use (&$counter) {
 42 |             return ++$counter;
 43 |         });
 44 | 
 45 |         $this->assertEquals(0, $counter);
 46 | 
 47 |         $initialize(); // $counter = 1
 48 | 
 49 |         $this->assertEquals(1, $initialize());
 50 | 
 51 |         $another = Functions::once(function () use (&$counter) {
 52 |             return ++$counter;
 53 |         });
 54 | 
 55 |         $another(); // $counter = 2
 56 | 
 57 |         $this->assertEquals(2, $another());
 58 |     }
 59 | 
 60 |     public function testPartial()
 61 |     {
 62 |         $const = Functions::p();
 63 |         $this->assertSame('placeholder for partial', $const());
 64 | 
 65 |         $subtract = function ($a, $b) {
 66 |             return $b - $a;
 67 |         };
 68 | 
 69 |         $sub5 = Functions::partial($subtract, 5);
 70 | 
 71 |         $this->assertEquals(15, $sub5(20));
 72 | 
 73 |         $subFrom20 = Functions::partial($subtract, Functions::p(), 20);
 74 | 
 75 |         $this->assertEquals(15, $subFrom20(5));
 76 |     }
 77 | 
 78 |     public function testCompose()
 79 |     {
 80 |         $greet = function ($name) {
 81 |             return "hi: $name";
 82 |         };
 83 | 
 84 |         $exclaim = function ($statement) {
 85 |             return strtoupper($statement) . '!';
 86 |         };
 87 | 
 88 |         $welcome = Functions::compose($greet, $exclaim);
 89 | 
 90 |         $this->assertEquals('hi: MOE!', $welcome('moe'));
 91 |     }
 92 | 
 93 |     public function testWrap()
 94 |     {
 95 |         $hello = function ($name) {
 96 |             return "hello: $name";
 97 |         };
 98 | 
 99 |         $moe = Functions::wrap($hello, function ($func) {
100 |             return 'before, ' . $func('moe') . ', after';
101 |         });
102 | 
103 |         $this->assertEquals('before, hello: moe, after', $moe());
104 | 
105 |         $anon = Functions::wrap($hello, function ($func, $name) {
106 |             return 'before, ' . $func($name) . ', after';
107 |         });
108 | 
109 |         $this->assertEquals('before, hello: sue, after', $anon('sue'));
110 |     }
111 | 
112 |     public function testThrottle()
113 |     {
114 |         $count = 0;
115 | 
116 |         $ping = Functions::throttle(function () use (&$count) {
117 |             return ++$count;
118 |         }, 100);
119 | 
120 |         // Creating the throttle calls it once inititally
121 |         $this->assertEquals(1, $count);
122 | 
123 |         $ping();
124 |         $ping();
125 |         $ping();
126 | 
127 |         // Should still not be called
128 |         $this->assertEquals(1, $count);
129 | 
130 |         usleep(100 * 1000); // convert to ms
131 | 
132 |         $ping();
133 | 
134 |         $this->assertEquals(2, $count);
135 | 
136 |         $ping = Functions::throttle(function () use (&$count) {
137 |             return ++$count;
138 |         }, 100, ['leading' => false]);
139 | 
140 |         // Disabled initial call
141 |         $this->assertEquals(2, $count);
142 | 
143 |         usleep(100 * 1000); // convert to ms
144 | 
145 |         $ping();
146 | 
147 |         $this->assertEquals(3, $count);
148 |     }
149 | 
150 |     public function testAfter()
151 |     {
152 |         $count = 0;
153 | 
154 |         $finished = Functions::after(3, function () use (&$count) {
155 |             return ++$count;
156 |         });
157 | 
158 |         $finished();
159 |         $finished();
160 | 
161 |         $this->assertEquals(0, $count);
162 | 
163 |         $finished(); // $count = 1
164 |         $finished(); // $count = 2
165 | 
166 |         $this->assertEquals(2, $count);
167 |     }
168 | 
169 |     public function testBefore()
170 |     {
171 |         $salary = 0;
172 | 
173 |         $askForRaise = function () use (&$salary) {
174 |             return ++$salary;
175 |         };
176 | 
177 |         $monthlyMeeting = Functions::before(3, $askForRaise);
178 | 
179 |         $monthlyMeeting();
180 |         $monthlyMeeting(); // $salary = 2
181 |         $monthlyMeeting(); // memoized
182 | 
183 |         $this->assertEquals(2, $salary);
184 |     }
185 | }
186 | 


--------------------------------------------------------------------------------
/src/Underscore.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Underscore;
  4 | 
  5 | /**
  6 |  * @method static Underscore from($item)
  7 |  * @method static Underscore range(int $start, int $stop, int $step = 1)
  8 |  * @method static Underscore times(int $count, int $function, int $step = 1)
  9 |  *
 10 |  * @method Underscore clone()
 11 |  * @method Underscore compact()
 12 |  * @method Underscore defaults(mixed $default, ...)
 13 |  * @method Underscore difference($values)
 14 |  * @method Underscore extend(mixed $source, ...)
 15 |  * @method Underscore filter(callable $iterator)
 16 |  * @method Underscore flatten()
 17 |  * @method Underscore groupBy(callable $iterator)
 18 |  * @method Underscore head(int $count = 1)
 19 |  * @method Underscore initial(int $count = 1)
 20 |  * @method Underscore invoke(callable $iterator)
 21 |  * @method Underscore keys()
 22 |  * @method Underscore last(int $count = 1)
 23 |  * @method Underscore map(callable $iterator)
 24 |  * @method Underscore pluck(mixed $key)
 25 |  * @method Underscore merge($values)
 26 |  * @method Underscore intersection($values)
 27 |  * @method Underscore reject(callable $iterator)
 28 |  * @method Underscore shuffle()
 29 |  * @method Underscore sortBy(callable $iterator)
 30 |  * @method Underscore tail(int $count = 1)
 31 |  * @method Underscore tap(callable $iterator)
 32 |  * @method Underscore thru(callable $iterator)
 33 |  * @method Underscore uniq()
 34 |  * @method Underscore values()
 35 |  * @method Underscore where(array $properties, $strict = true)
 36 |  * @method Underscore without($values)
 37 |  * @method Underscore zip(array $keys)
 38 |  *
 39 |  * @method Collection collection()
 40 |  * @method bool       all(callable $iterator)
 41 |  * @method bool       any(callable $iterator)
 42 |  * @method bool       contains(mixed $needle)
 43 |  * @method bool       find(callable $iterator)
 44 |  * @method mixed      indexOf(mixed $needle)
 45 |  * @method mixed      lastIndexOf(mixed $needle)
 46 |  * @method mixed      value()
 47 |  * @method mixed[]    toArray()
 48 |  * @method int        size()
 49 |  * @method mixed      min()
 50 |  * @method mixed      max()
 51 |  * @method boolean    has($key)
 52 |  * @method mixed      reduce(callable $iterator, mixed $initial = null)
 53 |  * @method mixed      reduceRight(callable $iterator, mixed $initial = null)
 54 |  */
 55 | class Underscore
 56 | {
 57 |     /** @var  Collection */
 58 |     protected $wrapped;
 59 | 
 60 |     /** @var array */
 61 |     protected static $mixins = [];
 62 | 
 63 |     /** @var Registry */
 64 |     protected static $registry;
 65 | 
 66 |     /**
 67 |      * Set the registry singleton.
 68 |      *
 69 |      * @param  Registry $registry
 70 |      * @return void
 71 |      */
 72 |     public static function setRegistry(Registry $registry)
 73 |     {
 74 |         static::$registry = $registry;
 75 |     }
 76 | 
 77 |     /**
 78 |      * Get the registry singleton.
 79 |      *
 80 |      * Creates a new registry if none exists.
 81 |      *
 82 |      * @return Registry
 83 |      */
 84 |     public static function getRegistry()
 85 |     {
 86 |         if (!static::$registry) {
 87 |             static::$registry = new Registry;
 88 |         }
 89 | 
 90 |         return static::$registry;
 91 |     }
 92 | 
 93 |     /**
 94 |      * Allows you to extend Underscore with your own utility functions.
 95 |      *
 96 |      * Pass a hash of {name: function} definitions to have your functions added
 97 |      * to the Underscore object, as well as the OOP wrapper.
 98 |      *
 99 |      * @param  array $functions
100 |      * @return void
101 |      */
102 |     public static function mixin(array $functions)
103 |     {
104 |         foreach ($functions as $name => $function) {
105 |             static::getRegistry()->alias($name, $function);
106 |         }
107 |     }
108 | 
109 |     /**
110 |      * @param Collection $wrapped
111 |      */
112 |     public function __construct(Collection $wrapped = null)
113 |     {
114 |         $this->wrapped = $wrapped;
115 |     }
116 | 
117 |     /**
118 |      * @param string $method
119 |      * @param array  $args
120 |      * @throws \BadMethodCallException
121 |      * @return $this
122 |      */
123 |     public function __call($method, $args)
124 |     {
125 |         return $this->executePayload(static::getRegistry()->instance($method), $args);
126 |     }
127 | 
128 |     /**
129 |      * @param string $method
130 |      * @param array  $args
131 |      * @return $this
132 |      */
133 |     public static function __callStatic($method, $args)
134 |     {
135 |         return call_user_func_array(static::getRegistry()->instance($method), $args);
136 |     }
137 | 
138 |     /**
139 |      * Payload is either Mutator or Accessor. Both are supposed to be callable.
140 |      *
141 |      * @param callable $payload
142 |      * @param array    $args
143 |      * @return $this|mixed
144 |      */
145 |     protected function executePayload($payload, $args)
146 |     {
147 |         array_unshift($args, $this->wrapped);
148 | 
149 |         if ($payload instanceof Mutator) {
150 |             /** @var $payload callable */
151 |             $this->wrapped = call_user_func_array($payload, $args);
152 | 
153 |             return $this;
154 |         } else {
155 |             return call_user_func_array($payload, $args);
156 |         }
157 |     }
158 | }
159 | 


--------------------------------------------------------------------------------
/src/Functions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Underscore;
  4 | 
  5 | class Functions
  6 | {
  7 |     /**
  8 |      * Creates a function that memoizes the result of the $payload
  9 |      *
 10 |      * @param callable $payload
 11 |      *
 12 |      * @return \Closure
 13 |      */
 14 |     public static function memoize($payload)
 15 |     {
 16 |         $function = function () use ($payload) {
 17 |             static $cache = [];
 18 |             $args = func_get_args();
 19 |             $hash = md5(serialize($args));
 20 | 
 21 |             if (!array_key_exists($hash, $cache)) {
 22 |                 $cache[$hash] = call_user_func_array($payload, $args);
 23 |             }
 24 | 
 25 |             return $cache[$hash];
 26 |         };
 27 | 
 28 |         return $function;
 29 |     }
 30 | 
 31 |     /**
 32 |      * Creates function that simply returns given argument
 33 |      *
 34 |      * @return \Closure
 35 |      */
 36 |     public static function nop()
 37 |     {
 38 |         return function ($item) {
 39 |             return $item;
 40 |         };
 41 |     }
 42 | 
 43 |     /**
 44 |      * Creates a version of the function that can only be called one time.
 45 |      *
 46 |      * Repeated calls to the modified function will have no effect, returning
 47 |      * the value from the original call. Useful for initialization functions,
 48 |      * instead of having to set a boolean flag and then check it later.
 49 |      *
 50 |      * @param callable $function
 51 |      * @return \Closure
 52 |      */
 53 |     public static function once($function)
 54 |     {
 55 |         $called = false;
 56 |         $value = null;
 57 | 
 58 |         return function () use ($function, &$called, &$value) {
 59 |             if (!$called) {
 60 |                 $args = func_get_args();
 61 |                 $value = call_user_func_array($function, $args);
 62 |                 $called = true;
 63 |             }
 64 | 
 65 |             return $value;
 66 |         };
 67 |     }
 68 | 
 69 |     /**
 70 |      * Provides a constant value that is only used for partial().
 71 |      *
 72 |      * @return \Closure
 73 |      */
 74 |     public static function p()
 75 |     {
 76 |         static $function;
 77 |         if (!$function) {
 78 |             $function = function () {
 79 |                 return 'placeholder for partial';
 80 |             };
 81 |         }
 82 | 
 83 |         return $function;
 84 |     }
 85 | 
 86 |     /**
 87 |      * Partially apply a function by filling in any number of its arguments.
 88 |      *
 89 |      * You may pass p() in your list of arguments to specify an argument that
 90 |      * should not be pre-filled, but left open to supply at call-time.
 91 |      *
 92 |      * @param callable $function
 93 |      * @param mixed    $arg
 94 |      * @param          mixed ...
 95 |      * @return \Closure
 96 |      */
 97 |     public static function partial($function, $arg)
 98 |     {
 99 |         $bound = func_get_args();
100 |         array_shift($bound); // remove $function
101 | 
102 |         $placeholder = static::p();
103 | 
104 |         return function () use ($function, $bound, $placeholder) {
105 |             $inject = func_get_args();
106 | 
107 |             $args = [];
108 |             foreach ($bound as $value) {
109 |                 if ($value === $placeholder) {
110 |                     $args[] = array_shift($inject);
111 |                 } else {
112 |                     $args[] = $value;
113 |                 }
114 |             }
115 | 
116 |             // Append any remaining arguments
117 |             $args = array_merge($args, $inject);
118 | 
119 |             return call_user_func_array($function, $args);
120 |         };
121 |     }
122 | 
123 |     /**
124 |      * Returns the composition of a list of functions.
125 |      *
126 |      * Each function consumes the return value of the function that follows.
127 |      * In math terms, composing the functions f(), g(), and h() produces f(g(h())).
128 |      *
129 |      * @param callable $function
130 |      * @param          callable ...
131 |      * @return \Closure
132 |      */
133 |     public static function compose($function)
134 |     {
135 |         $functions = array_reverse(func_get_args());
136 | 
137 |         return function ($value) use ($functions) {
138 |             foreach ($functions as $function) {
139 |                 $value = $function($value);
140 |             }
141 | 
142 |             return $value;
143 |         };
144 |     }
145 | 
146 |     /**
147 |      * Wraps the first function inside of the wrapper function, passing it as the first argument.
148 |      *
149 |      * This allows the wrapper to execute code before and after the function runs,
150 |      * adjust the arguments, and execute it conditionally.
151 |      *
152 |      * @param callable $function
153 |      * @param callable $wrapper
154 |      * @return \Closure
155 |      */
156 |     public static function wrap($function, $wrapper)
157 |     {
158 |         return function () use ($function, $wrapper) {
159 |             $args = func_get_args();
160 |             array_unshift($args, $function); // make $function the first argument
161 |             return call_user_func_array($wrapper, $args);
162 |         };
163 |     }
164 | 
165 |     /**
166 |      * Creates and returns a new, throttled version of the passed function.
167 |      *
168 |      * When invoked repeatedly, will only actually call the original function at
169 |      * most once per every wait milliseconds. Useful for rate-limiting events that
170 |      * occur faster than you can keep up with.
171 |      *
172 |      * By default, throttle will execute the function as soon as you call it
173 |      * for the first time, and, if you call it again any number of times during
174 |      * the wait period, as soon as that period is over. If you'd like to disable
175 |      * the leading-edge call, pass `leading => false`.
176 |      *
177 |      * NOTE: Does not support the `trailing` option because there is no timeout
178 |      * functionality in PHP (without using threads).
179 |      *
180 |      * NOTE: No arguments are passed to the function on the leading edge call!
181 |      *
182 |      * @param callable $function
183 |      * @param integer  $wait
184 |      * @param array    $options
185 |      * @return \Closure
186 |      */
187 |     public static function throttle($function, $wait, array $options = [])
188 |     {
189 |         $options += [
190 |             'leading' => true,
191 |         ]; // @codeCoverageIgnore
192 | 
193 |         $previous = 0;
194 | 
195 |         $callback = function () use ($function, $wait, &$previous) {
196 |             $now = floor(microtime(true) * 1000); // convert float to integer
197 | 
198 |             if (($wait - ($now - $previous)) <= 0) {
199 |                 $args = func_get_args();
200 |                 call_user_func_array($function, $args);
201 |                 $previous = $now;
202 |             }
203 |         };
204 | 
205 |         if ($options['leading'] !== false) {
206 |             $callback();
207 |         }
208 | 
209 |         return $callback;
210 |     }
211 | 
212 |     /**
213 |      * Creates a version of the function that will only be run after first being called count times.
214 |      *
215 |      * Useful for grouping asynchronous responses, where you want to be sure that
216 |      * all the async calls have finished, before proceeding.
217 |      *
218 |      * @param integer  $count
219 |      * @param callable $function
220 |      * @return \Closure
221 |      */
222 |     public static function after($count, $function)
223 |     {
224 |         return function () use ($function, &$count) {
225 |             if (--$count < 1) {
226 |                 $args = func_get_args();
227 | 
228 |                 return call_user_func_array($function, $args);
229 |             }
230 |         };
231 |     }
232 | 
233 |     /**
234 |      * Creates a version of the function that can be called no more than count times.
235 |      *
236 |      * The result of the last function call is memoized and returned when count has been reached.
237 |      *
238 |      * @param integer  $count
239 |      * @param callable $function
240 |      * @return \Closure
241 |      */
242 |     public static function before($count, $function)
243 |     {
244 |         $memo = null;
245 | 
246 |         return function () use ($function, &$count, &$memo) {
247 |             if (--$count > 0) {
248 |                 $args = func_get_args();
249 |                 $memo = call_user_func_array($function, $args);
250 |             }
251 | 
252 |             return $memo;
253 |         };
254 |     }
255 | }
256 | 


--------------------------------------------------------------------------------
/tests/UnderscoreTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Underscore\Test;
  4 | 
  5 | use Underscore\Collection;
  6 | use Underscore\Underscore;
  7 | 
  8 | class UnderscoreTest extends \PHPUnit_Framework_TestCase
  9 | {
 10 |     protected function getDummy()
 11 |     {
 12 |         $dummy = new \stdClass();
 13 |         $dummy->name = 'dummy';
 14 |         $dummy->foo = 'bar';
 15 |         $dummy->baz = 'qux';
 16 | 
 17 |         return $dummy;
 18 |     }
 19 | 
 20 |     /**
 21 |      * @return object
 22 |      */
 23 |     protected function getDummy2()
 24 |     {
 25 |         $dummy = $this->getDummy();
 26 |         $dummy->false = false;
 27 |         $dummy->null = null;
 28 |         $dummy->zero = 0;
 29 | 
 30 |         return $dummy;
 31 |     }
 32 | 
 33 |     protected function getDummy3()
 34 |     {
 35 |         $dummy = [
 36 |             'Angela' => [
 37 |                 'position' => 'dean',
 38 |                 'sex'      => 'female',
 39 |             ],
 40 |             'Bob'    => [
 41 |                 'position' => 'janitor',
 42 |                 'sex'      => 'male',
 43 |             ],
 44 |             'Mark'   => [
 45 |                 'position' => 'teacher',
 46 |                 'sex'      => 'male',
 47 |                 'tenured'  => true,
 48 |             ],
 49 |             'Wendy'  => [
 50 |                 'position' => 'teacher',
 51 |                 'sex'      => 'female',
 52 |                 'tenured'  => 1,
 53 |             ],
 54 |         ];
 55 | 
 56 |         return $dummy;
 57 |     }
 58 | 
 59 |     /**
 60 |      * @return array
 61 |      */
 62 |     public function getTestRangeData()
 63 |     {
 64 |         $out = [];
 65 |         // case #0
 66 |         $out[] = [0, 4, 1, [0, 1, 2, 3]];
 67 |         // case #1
 68 |         $out[] = [1, 5, 1, [1, 2, 3, 4]];
 69 |         // case #2
 70 |         $out[] = [0, 20, 5, [0, 5, 10, 15]];
 71 |         // case #3
 72 |         $out[] = [0, 0, 1, []];
 73 |         // case #4
 74 |         $out[] = [1, 2, 0, [], '\LogicException'];
 75 | 
 76 |         return $out;
 77 |     }
 78 | 
 79 |     public function testRegistry()
 80 |     {
 81 |         // Get current registry
 82 |         $registry = Underscore::getRegistry();
 83 | 
 84 |         $this->assertInstanceOf('Underscore\Registry', $registry);
 85 | 
 86 |         $mocked = $this->getMockBuilder('Underscore\Registry')->getMock();
 87 | 
 88 |         Underscore::setRegistry($mocked);
 89 | 
 90 |         $this->assertSame($mocked, Underscore::getRegistry());
 91 | 
 92 |         // Restore original registry
 93 |         Underscore::setRegistry($registry);
 94 |     }
 95 | 
 96 |     /**
 97 |      * @dataProvider getTestRangeData
 98 |      */
 99 |     public function testRange($start, $stop, $step, $expected, $exception = null)
100 |     {
101 |         $exception && $this->setExpectedException($exception);
102 | 
103 |         $this->assertEquals(
104 |             $expected,
105 |             Underscore::range($start, $stop, $step)->toArray()
106 |         );
107 |     }
108 | 
109 |     public function testTimes()
110 |     {
111 |         $fib = function ($n) {
112 |             // http://stackoverflow.com/a/27190248/49146
113 |             return (int) round(pow((sqrt(5) + 1) / 2, $n) / sqrt(5));
114 |         };
115 | 
116 |         $expected = [0, 1, 1, 2, 3, 5, 8, 13];
117 | 
118 |         $this->assertSame(
119 |             $expected,
120 |             Underscore::times(8, $fib)->toArray()
121 |         );
122 |     }
123 | 
124 |     public function testValue()
125 |     {
126 |         $value = Underscore::from($this->getDummy())->value();
127 |         $this->assertEquals((array)$this->getDummy(), $value);
128 |     }
129 | 
130 |     public function testInvoke()
131 |     {
132 |         $buffer = '';
133 |         Underscore::from($this->getDummy())
134 |             ->invoke(
135 |                 function ($value, $key) use (&$buffer) {
136 |                     $buffer .= sprintf('%s:%s|', $key, $value);
137 |                 }
138 |             );
139 |         $this->assertSame('name:dummy|foo:bar|baz:qux|', $buffer);
140 |     }
141 | 
142 |     public function testMap()
143 |     {
144 |         $value = Underscore::from($this->getDummy())
145 |             ->map(
146 |                 function ($value, $key) use (&$buffer) {
147 |                     return sprintf('%s:%s', $key, $value);
148 |                 }
149 |             )->toArray();
150 | 
151 |         $this->assertSame(
152 |             ['name' => 'name:dummy', 'foo' => 'foo:bar', 'baz' => 'baz:qux'],
153 |             $value
154 |         );
155 |     }
156 | 
157 |     public function testReduce()
158 |     {
159 |         $value = Underscore::from($this->getDummy())
160 |             ->reduce(
161 |                 function ($accu, $value) {
162 |                     $accu .= $value . ' ';
163 | 
164 |                     return $accu;
165 |                 },
166 |                 ''
167 |             );
168 | 
169 |         $this->assertSame('dummy bar qux ', $value);
170 |     }
171 | 
172 |     public function testReduceRight()
173 |     {
174 |         $value = Underscore::from($this->getDummy())
175 |             ->reduceRight(
176 |                 function ($accumulator, $value) {
177 |                     $accumulator .= $value . ' ';
178 | 
179 |                     return $accumulator;
180 |                 },
181 |                 ''
182 |             );
183 | 
184 |         $this->assertSame('qux bar dummy ', $value);
185 |     }
186 | 
187 |     public function testIndexOf()
188 |     {
189 |         $value = Underscore::from($this->getDummy())
190 |             ->indexOf('dummy');
191 | 
192 |         $this->assertSame('name', $value);
193 | 
194 |         $value = Underscore::from($this->getDummy2())
195 |             ->indexOf(false);
196 | 
197 |         $this->assertSame('false', $value);
198 |     }
199 | 
200 |     public function testLastIndexOf()
201 |     {
202 |         $value = Underscore::from([1, 2, 3])
203 |             ->lastIndexOf(2);
204 | 
205 |         $this->assertSame(1, $value);
206 | 
207 |         $value = Underscore::from([1, 2, 3, 4, 2])
208 |             ->lastIndexOf(2);
209 | 
210 |         $this->assertSame(4, $value);
211 | 
212 |         $object = new \stdClass;
213 |         $value = Underscore::from([clone $object, clone $object, $object])
214 |             ->lastIndexOf($object);
215 | 
216 |         $this->assertSame(2, $value);
217 |     }
218 | 
219 |     public function testMin()
220 |     {
221 |         $value = Underscore::from([1, 5, 1, 100, 8, 3])
222 |             ->min();
223 | 
224 |         $this->assertSame(1, $value);
225 |     }
226 | 
227 |     public function testMax()
228 |     {
229 |         $value = Underscore::from([1, 5, 1, 100, 8, 3])
230 |             ->max();
231 | 
232 |         $this->assertSame(100, $value);
233 |     }
234 | 
235 |     public function testpluck()
236 |     {
237 |         $value = Underscore::from([$this->getDummy(), $this->getDummy(), $this->getDummy()])
238 |             ->pluck('foo')
239 |             ->toArray();
240 | 
241 |         $this->assertSame(['bar', 'bar', 'bar'], $value);
242 | 
243 |         $value = Underscore::from($this->getDummy3())
244 |             ->pluck('position')
245 |             ->toArray();
246 | 
247 |         $this->assertSame([
248 |             'Angela' => 'dean',
249 |             'Bob' => 'janitor',
250 |             'Mark' => 'teacher',
251 |             'Wendy' => 'teacher',
252 |         ], $value);
253 |     }
254 | 
255 |     public function testpluckGetter()
256 |     {
257 |         $value = Underscore::from([new Dummy()])
258 |             ->pluck('getFoo')
259 |             ->toArray();
260 | 
261 |         $this->assertSame(['foo'], $value);
262 |     }
263 | 
264 |     public function testContains()
265 |     {
266 |         $this->assertTrue(Underscore::from($this->getDummy())->contains('bar'));
267 |         $this->assertFalse(Underscore::from($this->getDummy())->contains('baz'));
268 |     }
269 | 
270 |     public function testFind()
271 |     {
272 |         $iterator = function ($needle) {
273 |             return function ($value) use ($needle) {
274 |                 return $value === $needle;
275 |             };
276 |         };
277 |         $this->assertTrue(Underscore::from($this->getDummy())->find($iterator('bar')));
278 |         $this->assertFalse(Underscore::from($this->getDummy())->find($iterator('foo')));
279 |     }
280 | 
281 |     public function testFilter()
282 |     {
283 |         $value = Underscore::from($this->getDummy())
284 |             ->filter(
285 |                 function ($value) {
286 |                     return 3 < strlen($value);
287 |                 }
288 |             )
289 |             ->toArray();
290 | 
291 |         $this->assertSame(['name' => 'dummy'], $value);
292 |     }
293 | 
294 |     public function testReject()
295 |     {
296 |         $value = Underscore::from($this->getDummy())
297 |             ->reject(
298 |                 function ($value) {
299 |                     return 3 < strlen($value);
300 |                 }
301 |             )
302 |             ->toArray();
303 | 
304 |         $this->assertSame(['foo' => 'bar', 'baz' => 'qux'], $value);
305 |     }
306 | 
307 |     public function testAny()
308 |     {
309 |         $value = Underscore::from($this->getDummy())
310 |             ->any(
311 |                 function ($value) {
312 |                     return 3 < strlen($value);
313 |                 }
314 |             );
315 | 
316 |         $this->assertSame(true, $value);
317 | 
318 |         $value = Underscore::from($this->getDummy())
319 |             ->any(
320 |                 function ($value) {
321 |                     return strlen($value) < 2;
322 |                 }
323 |             );
324 | 
325 |         $this->assertSame(false, $value);
326 |     }
327 | 
328 |     public function testAll()
329 |     {
330 |         $value = Underscore::from($this->getDummy())
331 |             ->all(
332 |                 function ($value) {
333 |                     return 3 <= strlen($value);
334 |                 }
335 |             );
336 | 
337 |         $this->assertSame(true, $value);
338 | 
339 |         $value = Underscore::from($this->getDummy())
340 |             ->all(
341 |                 function ($value) {
342 |                     return 3 < strlen($value);
343 |                 }
344 |             );
345 | 
346 |         $this->assertSame(false, $value);
347 |     }
348 | 
349 |     public function testSize()
350 |     {
351 |         $value = Underscore::from($this->getDummy())
352 |             ->size();
353 | 
354 |         $this->assertSame(3, $value);
355 |     }
356 | 
357 |     public function testHead()
358 |     {
359 |         $value = Underscore::from($this->getDummy())
360 |             ->head(2)
361 |             ->value();
362 | 
363 |         $this->assertSame(['name' => 'dummy', 'foo' => 'bar'], $value);
364 |     }
365 | 
366 |     public function testTail()
367 |     {
368 |         $value = Underscore::from($this->getDummy())
369 |             ->tail(1)
370 |             ->value();
371 | 
372 |         $this->assertSame(['foo' => 'bar', 'baz' => 'qux'], $value);
373 |     }
374 | 
375 |     public function testInitial()
376 |     {
377 |         $value = Underscore::from($this->getDummy())
378 |             ->initial(2)
379 |             ->value();
380 | 
381 |         $this->assertSame(['name' => 'dummy'], $value);
382 |     }
383 | 
384 |     public function testLast()
385 |     {
386 |         $value = Underscore::from($this->getDummy())
387 |             ->last(2)
388 |             ->value();
389 | 
390 |         $this->assertSame(['foo' => 'bar', 'baz' => 'qux'], $value);
391 |     }
392 | 
393 |     public function testCompact()
394 |     {
395 |         $value = Underscore::from($this->getDummy2())
396 |             ->compact()
397 |             ->toArray();
398 | 
399 |         $this->assertSame(['name' => 'dummy', 'foo' => 'bar', 'baz' => 'qux'], $value);
400 |     }
401 | 
402 |     public function testWithout()
403 |     {
404 |         $value = Underscore::from($this->getDummy())
405 |             ->without(['dummy'])
406 |             ->toArray();
407 | 
408 |         $this->assertSame(['foo' => 'bar', 'baz' => 'qux'], $value);
409 |     }
410 | 
411 |     public function testMerge()
412 |     {
413 |         $value = Underscore::from($this->getDummy())
414 |             ->merge(new Collection($this->getDummy2()))
415 |             ->toArray();
416 | 
417 |         $this->assertSame(
418 |             [
419 |                 'name'  => 'dummy',
420 |                 'foo'   => 'bar',
421 |                 'baz'   => 'qux',
422 |                 'false' => false,
423 |                 'null'  => null,
424 |                 'zero'  => 0,
425 |             ],
426 |             $value
427 |         );
428 |     }
429 | 
430 |     public function testDifference()
431 |     {
432 |         $one = ['yellow', 'pink', 'red', 'white', 'blue'];
433 |         $two = ['red', 'white', 'blue'];
434 | 
435 |         $value = Underscore::from($one)
436 |             ->difference($two)
437 |             ->toArray();
438 | 
439 |         $this->assertSame(array_values($value), [
440 |             'yellow',
441 |             'pink',
442 |         ]);
443 | 
444 |         $one = [
445 |             'name'  => 'John',
446 |             'food'  => 'bacon',
447 |             'sport' => 'tennis',
448 |             'color' => 'red',
449 |         ];
450 | 
451 |         $two = [
452 |             'name'  => 'John',
453 |             'color' => 'gray',
454 |             'food'  => 'tofu',
455 |             'sport' => 'tennis',
456 |         ];
457 | 
458 |         $value = Underscore::from($one)
459 |             ->difference($two)
460 |             ->toArray();
461 | 
462 |         // In this scenario, preserving keys is important.
463 |         $this->assertSame($value, [
464 |             'food'  => 'bacon',
465 |             'color' => 'red',
466 |         ]);
467 | 
468 |         // No difference, with a Traversable
469 |         $values = new \ArrayObject([
470 |             'foo' => 'bar',
471 |             'fizz' => 'bizz',
472 |         ]);
473 | 
474 |         $value = Underscore::from($values)
475 |             ->difference($values)
476 |             ->toArray();
477 | 
478 |         $this->assertEmpty($value);
479 |     }
480 | 
481 |     public function testIntersection()
482 |     {
483 |         $one = ['yellow', 'pink', 'white'];
484 |         $two = ['red', 'white', 'blue'];
485 | 
486 |         $value = Underscore::from($one)
487 |             ->intersection($two)
488 |             ->toArray();
489 | 
490 |         // Intersection will preserve keys, but we do not need to verify that.
491 |         $this->assertSame(array_values($value), [
492 |             'white',
493 |         ]);
494 | 
495 |         // Run the same test, but with an array instead of a collection.
496 |         $value = Underscore::from($one)
497 |             ->intersection(new Collection($two))
498 |             ->toArray();
499 | 
500 |         $this->assertSame(array_values($value), [
501 |             'white',
502 |         ]);
503 | 
504 |         $one = [
505 |             'name'  => 'John',
506 |             'food'  => 'bacon',
507 |             'sport' => 'tennis',
508 |             'color' => 'red',
509 |         ];
510 | 
511 |         $two = [
512 |             'name'  => 'John',
513 |             'color' => 'gray',
514 |             'food'  => 'tofu',
515 |             'sport' => 'tennis',
516 |         ];
517 | 
518 |         $value = Underscore::from($one)
519 |             ->intersection($two)
520 |             ->toArray();
521 | 
522 |         // In this scenario, preserving keys is important.
523 |         $this->assertSame($value, [
524 |             'name'  => 'John',
525 |             'sport' => 'tennis',
526 |         ]);
527 |     }
528 | 
529 |     public function testValues()
530 |     {
531 |         $value = Underscore::from($this->getDummy())
532 |             ->values()
533 |             ->toArray();
534 | 
535 |         $this->assertSame(
536 |             [
537 |                 'dummy',
538 |                 'bar',
539 |                 'qux',
540 |             ],
541 |             $value
542 |         );
543 |     }
544 | 
545 |     public function testKeys()
546 |     {
547 |         $value = Underscore::from($this->getDummy())
548 |             ->keys()
549 |             ->toArray();
550 | 
551 |         $this->assertSame(
552 |             [
553 |                 'name',
554 |                 'foo',
555 |                 'baz',
556 |             ],
557 |             $value
558 |         );
559 |     }
560 | 
561 |     public function testHas()
562 |     {
563 |         $collection = Underscore::from($this->getDummy());
564 | 
565 |         $this->assertTrue($collection->has('name'));
566 |         $this->assertTrue($collection->has('foo'));
567 |         $this->assertTrue($collection->has('baz'));
568 | 
569 |         $this->assertFalse($collection->has('nope'));
570 |         $this->assertFalse($collection->has('missing'));
571 |     }
572 | 
573 |     public function testClone()
574 |     {
575 |         $original = $this->getDummy();
576 |         $cloned = Underscore::from($original)
577 |             ->clone()
578 |             ->without(['dummy'])
579 |             ->value();
580 | 
581 |         $this->assertNotEquals(
582 |             Underscore::from($original)->value(),
583 |             $cloned
584 |         );
585 |     }
586 | 
587 |     public function testZip()
588 |     {
589 |         $value = Underscore::from($this->getDummy())
590 |             ->zip(['a', 1, '42'])
591 |             ->toArray();
592 | 
593 |         $this->assertSame(
594 |             [
595 |                 'a'  => 'dummy',
596 |                 1    => 'bar',
597 |                 '42' => 'qux',
598 |             ],
599 |             $value
600 |         );
601 | 
602 |         $this->setExpectedException('\LogicException');
603 |         Underscore::from($this->getDummy())
604 |             ->zip(['a']);
605 |     }
606 | 
607 |     public function testGroupBy()
608 |     {
609 |         $value = Underscore::from($this->getDummy())
610 |             ->groupBy('strlen')
611 |             ->toArray();
612 | 
613 |         $this->assertSame(
614 |             [
615 |                 5 => ['dummy'],
616 |                 3 => ['bar', 'qux'],
617 |             ],
618 |             $value
619 |         );
620 |     }
621 | 
622 |     public function testSortBy()
623 |     {
624 |         $value = Underscore::from($this->getDummy())
625 |             ->sortBy('strlen')
626 |             ->toArray();
627 | 
628 |         $this->assertSame(
629 |             [
630 |                 'bar',
631 |                 'qux',
632 |                 'dummy',
633 |             ],
634 |             $value
635 |         );
636 |     }
637 | 
638 |     /**
639 |      * @return array
640 |      */
641 |     public function getTestFlattenData()
642 |     {
643 |         $out = [];
644 |         // case #0
645 |         $out[] = [
646 |             [1, 2, [3, 4]],
647 |             [1, 2, 3, 4],
648 |         ];
649 | 
650 |         return $out;
651 |     }
652 | 
653 |     /**
654 |      * @dataProvider getTestFlattenData
655 |      */
656 |     public function testFlatten($input, $expected)
657 |     {
658 |         $value = Underscore::from($input)
659 |             ->flatten()
660 |             ->toArray();
661 | 
662 |         $this->assertSame($expected, $value);
663 |     }
664 | 
665 |     public function testTap()
666 |     {
667 |         $dummy = $this->getDummy();
668 | 
669 |         $mock = $this->getMock('stdClass', ['test']);
670 |         $mock->expects($this->once())->method('test')->with((array)$dummy);
671 | 
672 |         Underscore::from($dummy)->tap([$mock, 'test']);
673 |     }
674 | 
675 |     public function testThru()
676 |     {
677 |         $dummy = $this->getDummy();
678 | 
679 |         $mock = $this->getMock('stdClass', ['test']);
680 |         $mock->expects($this->once())->method('test')->with((array)$dummy)->willReturn([123]);
681 | 
682 |         $this->assertEquals([123], Underscore::from($dummy)->thru([$mock, 'test'])->value());
683 |     }
684 | 
685 |     /**
686 |      * @expectedException \BadMethodCallException
687 |      */
688 |     public function testCallUnknownMethod()
689 |     {
690 |         Underscore::from([])->foobar();
691 |     }
692 | 
693 |     /**
694 |      * @return array
695 |      */
696 |     public function getTestUniqData()
697 |     {
698 |         $out = [];
699 |         // case #0
700 |         $out[] = [
701 |             [1, 2, 3, 4, 4, 3],
702 |             [1, 2, 3, 4],
703 |         ];
704 |         // case #1
705 |         $obj1 = new \StdClass;
706 |         $obj2 = new \StdClass;
707 |         $obj3 = $obj1;
708 |         $out[] = [
709 |             [$obj1, $obj1, $obj2, $obj3],
710 |             [$obj1, $obj2],
711 |         ];
712 |         // case #2
713 |         $out[] = [
714 |             [true, false, 1, 0, 0.0, 0.00001],
715 |             [true, false, 1, 0, 0.0, 0.00001],
716 |         ];
717 | 
718 |         return $out;
719 |     }
720 | 
721 |     /**
722 |      * @dataProvider getTestUniqData
723 |      */
724 |     public function testUniq($input, $expected)
725 |     {
726 |         $value = Underscore::from($input)
727 |             ->uniq()
728 |             ->toArray();
729 | 
730 |         $this->assertEquals(array_values($expected), array_values($value));
731 |     }
732 | 
733 |     public function testExtend()
734 |     {
735 |         $collection = Underscore::from($this->getDummy())
736 |             ->extend([
737 |                 'name' => 'extended',
738 |             ]);
739 | 
740 |         $this->assertSame([
741 |             'name' => 'extended',
742 |             'foo'  => 'bar',
743 |             'baz'  => 'qux',
744 |         ], $collection->toArray());
745 | 
746 |         $collection = $collection->extend((object)[
747 |             'name' => 'obj',
748 |         ], (object)[
749 |             'name' => 'test',
750 |             'add'  => 'multi'
751 |         ]);
752 | 
753 |         $this->assertSame([
754 |             'name' => 'test',
755 |             'foo'  => 'bar',
756 |             'baz'  => 'qux',
757 |             'add'  => 'multi'
758 |         ], $collection->toArray());
759 |     }
760 | 
761 |     public function testDefaults()
762 |     {
763 |         $collection = Underscore::from($this->getDummy())
764 |             ->defaults([
765 |                 'name' => 'extended',
766 |             ]);
767 | 
768 |         $this->assertSame([
769 |             'name' => 'dummy',
770 |             'foo'  => 'bar',
771 |             'baz'  => 'qux',
772 |         ], $collection->toArray());
773 | 
774 |         $collection = $collection->defaults((object)[
775 |             'bar' => 'gold',
776 |         ], (object)[
777 |             'bar'   => 'silver',
778 |             'color' => 'blue'
779 |         ]);
780 | 
781 |         $this->assertSame([
782 |             'name'  => 'dummy',
783 |             'foo'   => 'bar',
784 |             'baz'   => 'qux',
785 |             'bar'   => 'gold',
786 |             'color' => 'blue'
787 |         ], $collection->toArray());
788 |     }
789 | 
790 |     public function testWhere()
791 |     {
792 |         $found = Underscore::from($this->getDummy3())
793 |             ->where([
794 |                 'sex' => 'female',
795 |             ])
796 |             ->keys()
797 |             ->toArray();
798 | 
799 |         $this->assertSame(['Angela', 'Wendy'], $found);
800 | 
801 |         $found = Underscore::from($this->getDummy3())
802 |             ->where([
803 |                 'position' => 'teacher',
804 |             ])
805 |             ->keys()
806 |             ->toArray();
807 | 
808 |         $this->assertSame(['Mark', 'Wendy'], $found);
809 | 
810 |         $found = Underscore::from($this->getDummy3())
811 |             ->where([
812 |                 'position' => 'teacher',
813 |                 'tenured'  => true,
814 |             ])
815 |             ->keys()
816 |             ->toArray();
817 | 
818 |         $this->assertSame(['Mark'], $found);
819 | 
820 |         $found = Underscore::from($this->getDummy3())
821 |             ->where([
822 |                 'position' => 'teacher',
823 |                 'tenured'  => true,
824 |             ], $strict = false)
825 |             ->keys()
826 |             ->toArray();
827 | 
828 |         $this->assertSame(['Mark', 'Wendy'], $found);
829 | 
830 |         $found = Underscore::from($this->getDummy3())
831 |             ->where([
832 |                 'sex'      => 'female',
833 |                 'position' => 'teacher',
834 |             ])
835 |             ->keys()
836 |             ->toArray();
837 | 
838 |         $this->assertSame(['Wendy'], $found);
839 | 
840 |         $found = Underscore::from($this->getDummy3())
841 |             ->where([
842 |                 'sex'      => 'male',
843 |                 'position' => 'dean',
844 |             ])
845 |             ->keys()
846 |             ->toArray();
847 | 
848 |         $this->assertSame([], $found);
849 |     }
850 | 
851 |     public function testMixin()
852 |     {
853 |         Underscore::mixin([
854 |             'falsey' => function ($collection) {
855 |                 $output = clone $collection;
856 | 
857 |                 foreach ($collection as $k => $v) {
858 |                     if (!empty($v)) {
859 |                         unset($output[$k]);
860 |                     }
861 |                 }
862 | 
863 |                 return $output;
864 |             }
865 |         ]);
866 | 
867 |         $value = Underscore::from($this->getDummy2())
868 |             ->falsey()
869 |             ->toArray();
870 | 
871 |         $this->assertSame($value, [
872 |             'false' => false,
873 |             'null'  => null,
874 |             'zero'  => 0,
875 |         ]);
876 |         $value = Underscore::from($this->getDummy())
877 |             ->falsey()
878 |             ->toArray();
879 | 
880 |         $this->assertSame($value, []);
881 |     }
882 | 
883 |     public function testShuffle()
884 |     {
885 |         $original = $this->getDummy3();
886 |         $values = Underscore::from($original)
887 |             ->shuffle()
888 |             ->toArray();
889 | 
890 |         // Not necessarily the same, but contains the same values.
891 |         // We cannot check the sorting of the keys because it is entirely
892 |         // possible that keys were not randomized at all!
893 |         $this->assertEquals($original, $values);
894 |     }
895 | }
896 | 


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