├── .gitignore
├── src
    ├── Reports
    │   ├── FailureReport.php
    │   ├── ReportInterface.php
    │   └── SimpleReport.php
    ├── Exceptions
    │   ├── AxiomException.php
    │   └── AtomException.php
    ├── Atoms
    │   ├── AtomInterface.php
    │   ├── StringAtom.php
    │   └── IntegerAtom.php
    ├── Bags
    │   ├── ArrayBag.php
    │   └── BagInterface.php
    ├── Recipients
    │   ├── OnCreateRecipientInterface.php
    │   ├── OnUpdateRecipientInterface.php
    │   └── OnDeleteRecipientInterface.php
    ├── Factories
    │   └── FactoryInterface.php
    ├── Models
    │   └── ModelInterface.php
    └── Repositories
    │   ├── InMemoryRepository.php
    │   └── RepositoryInterface.php
├── CONTRIBUTING.md
├── .travis.yml
├── console
    ├── Stubs
    │   ├── bag.stub
    │   ├── atom.stub
    │   ├── factory.stub
    │   ├── model.stub
    │   ├── report.stub
    │   ├── repository.stub
    │   └── Manager.php
    ├── Commands
    │   ├── MakeAtomCommand.php
    │   ├── MakeBagCommand.php
    │   ├── MakeReportCommand.php
    │   ├── MakeFactoryCommand.php
    │   ├── MakeRepositoryCommand.php
    │   ├── MakeModelCommand.php
    │   ├── MakeStackCommand.php
    │   └── BaseCommand.php
    └── Config.php
├── tests
    ├── Atoms
    │   ├── StringAtomTest.php
    │   └── IntegerAtomTest.php
    ├── Bags
    │   └── ArrayBagTest.php
    ├── Reports
    │   └── SimpleReportTest.php
    ├── Console
    │   └── ConfigTest.php
    └── Repositories
    │   └── InMemoryRepositoryTest.php
├── composer.json
├── LICENSE
├── phpunit.xml
├── bin
    └── axiom
├── README.md
└── composer.lock


/.gitignore:
--------------------------------------------------------------------------------
1 | /vendor
2 | axiom.yaml
3 | /build
4 | 


--------------------------------------------------------------------------------
/src/Reports/FailureReport.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Enzyme\Axiom\Reports;
4 | 
5 | class FailureReport extends SimpleReport
6 | {
7 |     //
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Exceptions/AxiomException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Exceptions;
 4 | 
 5 | use Exception;
 6 | 
 7 | class AxiomException extends Exception
 8 | {
 9 |     //
10 | }
11 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
1 | # Contributing
2 | 
3 | 1. Any additions should be made on the `bleeding` branch, and the PR's sent there.
4 | 2. All code should be framework agnostic.
5 | 3. Be SOLID and DRY.
6 | 4. All code should be well tested.
7 | 


--------------------------------------------------------------------------------
/src/Atoms/AtomInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Atoms;
 4 | 
 5 | interface AtomInterface
 6 | {
 7 |     /**
 8 |      * Get the underlying value associated with this atom.
 9 |      *
10 |      * @return mixed
11 |      */
12 |     public function getValue();
13 | }
14 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - "5.5"
 5 |   - "5.6"
 6 |   - "nightly"
 7 |   - "hhvm"
 8 | 
 9 | before_script:
10 |   - composer install
11 | 
12 | script:
13 |   - mkdir -p build/logs
14 |   - php vendor/bin/phpunit -c phpunit.xml
15 | 
16 | after_script:
17 |   - travis_retry php vendor/bin/coveralls -v
18 | 


--------------------------------------------------------------------------------
/src/Exceptions/AtomException.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Exceptions;
 4 | 
 5 | class AtomException extends AxiomException
 6 | {
 7 |     public function __construct($class, $value)
 8 |     {
 9 |         parent::__construct(
10 |             "The atom [{$class}] could not process the value [{$value}]."
11 |         );
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/console/Stubs/bag.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace %namespace%;
 4 | 
 5 | use Enzyme\Axiom\Bags\BagInterface;
 6 | 
 7 | class %name%Bag implements BagInterface
 8 | {
 9 |     public function get($key)
10 |     {
11 |         //
12 |     }
13 | 
14 |     public function getAll()
15 |     {
16 |         //
17 |     }
18 | 
19 |     public function has($key)
20 |     {
21 |         //
22 |     }
23 | }
24 | 


--------------------------------------------------------------------------------
/console/Stubs/atom.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace %namespace%;
 4 | 
 5 | use Enzyme\Axiom\Atoms\AtomInterface;
 6 | use Enzyme\Axiom\Exceptions\AtomException;
 7 | 
 8 | class %name%Atom implements AtomInterface
 9 | {
10 |     protected $value;
11 | 
12 |     public function __construct($value)
13 |     {
14 |         //
15 |     }
16 | 
17 |     public function getValue()
18 |     {
19 |         return $this->value;
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/console/Stubs/factory.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace %namespace%;
 4 | 
 5 | use Enzyme\Axiom\Bags\BagInterface;
 6 | use Enzyme\Axiom\Models\ModelInterface;
 7 | use Enzyme\Axiom\Factories\FactoryInterface;
 8 | 
 9 | class %name%Factory implements FactoryInterface
10 | {
11 |     public function make(BagInterface $data)
12 |     {
13 |         //
14 |     }
15 | 
16 |     public function update(ModelInterface $model, BagInterface $data)
17 |     {
18 |         //
19 |     }
20 | }
21 | 


--------------------------------------------------------------------------------
/console/Stubs/model.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Models;
 4 | 
 5 | use Enzyme\Axiom\Models\ModelInterface;
 6 | 
 7 | class %name% implements ModelInterface
 8 | {
 9 |     public function identity()
10 |     {
11 |         //
12 |     }
13 | 
14 |     public function has($attribute)
15 |     {
16 |         //
17 |     }
18 | 
19 |     public function get($attribute)
20 |     {
21 |         //
22 |     }
23 | 
24 |     public function getAll()
25 |     {
26 |         //
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Atoms/StringAtom.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Atoms;
 4 | 
 5 | use Enzyme\Axiom\Exceptions\AtomException;
 6 | 
 7 | class StringAtom implements AtomInterface
 8 | {
 9 |     protected $value;
10 | 
11 |     public function __construct($value)
12 |     {
13 |         if (is_string($value) === false) {
14 |             throw new AtomException(get_class($this), $value);
15 |         }
16 | 
17 |         $this->value = $value;
18 |     }
19 | 
20 |     public function getValue()
21 |     {
22 |         return $this->value;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/src/Reports/ReportInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Reports;
 4 | 
 5 | interface ReportInterface
 6 | {
 7 |     /**
 8 |      * Get the human readable message associated with this report.
 9 |      *
10 |      * @return string
11 |      */
12 |     public function getMessage();
13 | 
14 |     /**
15 |      * Whether this report has additional details.
16 |      *
17 |      * @return boolean
18 |      */
19 |     public function hasDetails();
20 | 
21 |     /**
22 |      * Get the additional details associated with this report.
23 |      *
24 |      * @return array
25 |      */
26 |     public function getDetails();
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Reports/SimpleReport.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Reports;
 4 | 
 5 | class SimpleReport implements ReportInterface
 6 | {
 7 |     protected $message;
 8 |     protected $details;
 9 | 
10 |     public function __construct($message, $details = [])
11 |     {
12 |         $this->message = $message;
13 |         $this->details = $details;
14 |     }
15 | 
16 |     public function getMessage()
17 |     {
18 |         return $this->message;
19 |     }
20 | 
21 |     public function hasDetails()
22 |     {
23 |         return count($this->details) > 0;
24 |     }
25 | 
26 |     public function getDetails()
27 |     {
28 |         return $this->details;
29 |     }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/Bags/ArrayBag.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Bags;
 4 | 
 5 | class ArrayBag implements BagInterface
 6 | {
 7 |     protected $store;
 8 | 
 9 |     public function __construct(array $store)
10 |     {
11 |         $this->store = $store;
12 |     }
13 | 
14 |     public function get($key)
15 |     {
16 |         if ($this->has($key)) {
17 |             return $this->store[$key];
18 |         }
19 | 
20 |         return null;
21 |     }
22 | 
23 |     public function getAll()
24 |     {
25 |         return $this->store;
26 |     }
27 | 
28 |     public function has($key)
29 |     {
30 |         return isset($this->store[$key])
31 |             && array_key_exists($key, $this->store);
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/console/Stubs/report.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace %namespace%;
 4 | 
 5 | use Enzyme\Axiom\Reports\ReportInterface;
 6 | 
 7 | class %name%Report implements ReportInterface
 8 | {
 9 |     protected $message;
10 |     protected $details;
11 | 
12 |     public function __construct($message, $details = [])
13 |     {
14 |         $this->message = $message;
15 |         $this->details = $details;
16 |     }
17 | 
18 |     public function getMessage()
19 |     {
20 |         return $this->message;
21 |     }
22 | 
23 |     public function hasDetails()
24 |     {
25 |         return count($this->details) > 0;
26 |     }
27 | 
28 |     public function getDetails()
29 |     {
30 |         return $this->details;
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/src/Atoms/IntegerAtom.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Atoms;
 4 | 
 5 | use Enzyme\Axiom\Exceptions\AtomException;
 6 | 
 7 | class IntegerAtom implements AtomInterface
 8 | {
 9 |     protected $value;
10 | 
11 |     public function __construct($value)
12 |     {
13 |         if ($this->isInvalidOrFloat($value)) {
14 |             throw new AtomException(get_class($this), $value);
15 |         }
16 | 
17 |         $this->value = (int) $value;
18 |     }
19 | 
20 |     public function getValue()
21 |     {
22 |         return $this->value;
23 |     }
24 | 
25 |     protected function isInvalidOrFloat($value)
26 |     {
27 |         return is_numeric($value) === false || is_float($value) === true;
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/console/Commands/MakeAtomCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Console\Commands;
 4 | 
 5 | use Symfony\Component\Console\Input\InputArgument;
 6 | use Symfony\Component\Console\Input\InputInterface;
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | 
 9 | class MakeAtomCommand extends BaseCommand
10 | {
11 |     /**
12 |      * {@inheritDoc}
13 |      */
14 |     protected function getGeneratorType()
15 |     {
16 |         return 'atom';
17 |     }
18 | 
19 |     /**
20 |      * {@inheritDoc}
21 |      */
22 |     protected function execute(InputInterface $input, OutputInterface $output)
23 |     {
24 |         parent::execute($input, $output);
25 | 
26 |         $this->executeGeneration($input, $output);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/console/Commands/MakeBagCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Console\Commands;
 4 | 
 5 | use Symfony\Component\Console\Input\InputArgument;
 6 | use Symfony\Component\Console\Input\InputInterface;
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | 
 9 | class MakeBagCommand extends BaseCommand
10 | {
11 |     /**
12 |      * {@inheritDoc}
13 |      */
14 |     protected function getGeneratorType()
15 |     {
16 |         return 'bag';
17 |     }
18 | 
19 |     /**
20 |      * {@inheritDoc}
21 |      */
22 |     protected function execute(InputInterface $input, OutputInterface $output)
23 |     {
24 |         parent::execute($input, $output);
25 | 
26 |         $this->executeGeneration($input, $output);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/console/Commands/MakeReportCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Console\Commands;
 4 | 
 5 | use Symfony\Component\Console\Input\InputArgument;
 6 | use Symfony\Component\Console\Input\InputInterface;
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | 
 9 | class MakeReportCommand extends BaseCommand
10 | {
11 |     /**
12 |      * {@inheritDoc}
13 |      */
14 |     protected function getGeneratorType()
15 |     {
16 |         return 'report';
17 |     }
18 | 
19 |     /**
20 |      * {@inheritDoc}
21 |      */
22 |     protected function execute(InputInterface $input, OutputInterface $output)
23 |     {
24 |         parent::execute($input, $output);
25 | 
26 |         $this->executeGeneration($input, $output);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Bags/BagInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Bags;
 4 | 
 5 | interface BagInterface
 6 | {
 7 |     /**
 8 |      * Get the value associated with the given key. If the key does not
 9 |      * exist, return null instead.
10 |      *
11 |      * @param string $key
12 |      *
13 |      * @return mixed
14 |      */
15 |     public function get($key);
16 | 
17 |     /**
18 |      * Get all the key/value pairs for this bag.
19 |      *
20 |      * @return array
21 |      */
22 |     public function getAll();
23 | 
24 |     /**
25 |      * Check whether there is a value associated with the given key.
26 |      *
27 |      * @param string $key
28 |      *
29 |      * @return boolean
30 |      */
31 |     public function has($key);
32 | }
33 | 


--------------------------------------------------------------------------------
/console/Commands/MakeFactoryCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Console\Commands;
 4 | 
 5 | use Symfony\Component\Console\Input\InputArgument;
 6 | use Symfony\Component\Console\Input\InputInterface;
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | 
 9 | class MakeFactoryCommand extends BaseCommand
10 | {
11 |     /**
12 |      * {@inheritDoc}
13 |      */
14 |     protected function getGeneratorType()
15 |     {
16 |         return 'factory';
17 |     }
18 | 
19 |     /**
20 |      * {@inheritDoc}
21 |      */
22 |     protected function execute(InputInterface $input, OutputInterface $output)
23 |     {
24 |         parent::execute($input, $output);
25 | 
26 |         $this->executeGeneration($input, $output);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/console/Commands/MakeRepositoryCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Console\Commands;
 4 | 
 5 | use Symfony\Component\Console\Input\InputArgument;
 6 | use Symfony\Component\Console\Input\InputInterface;
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | 
 9 | class MakeRepositoryCommand extends BaseCommand
10 | {
11 |     /**
12 |      * {@inheritDoc}
13 |      */
14 |     protected function getGeneratorType()
15 |     {
16 |         return 'repository';
17 |     }
18 | 
19 |     /**
20 |      * {@inheritDoc}
21 |      */
22 |     protected function execute(InputInterface $input, OutputInterface $output)
23 |     {
24 |         parent::execute($input, $output);
25 | 
26 |         $this->executeGeneration($input, $output);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Recipients/OnCreateRecipientInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Recipients;
 4 | 
 5 | use Enzyme\Axiom\Models\ModelInterface;
 6 | use Enzyme\Axiom\Reports\ReportInterface;
 7 | 
 8 | interface OnCreateRecipientInterface
 9 | {
10 |     /**
11 |      * Called when the creation of a model was a success.
12 |      *
13 |      * @param ModelInterface $model The newly created model.
14 |      *
15 |      * @return mixed
16 |      */
17 |     public function onCreateSuccess(ModelInterface $model);
18 | 
19 |     /**
20 |      * Called when the creation of a model was a failure.
21 |      *
22 |      * @param ReportInterface $report The failure report.
23 |      *
24 |      * @return mixed
25 |      */
26 |     public function onCreateFailure(ReportInterface $report);
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Factories/FactoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Factories;
 4 | 
 5 | use Enzyme\Axiom\Bags\BagInterface;
 6 | use Enzyme\Axiom\Models\ModelInterface;
 7 | 
 8 | interface FactoryInterface
 9 | {
10 |     /**
11 |      * Make a new model given the data provided.
12 |      *
13 |      * @param BagInterface $data
14 |      *
15 |      * @return \Enzyme\Axiom\Models\ModelInterface
16 |      */
17 |     public function make(BagInterface $data);
18 | 
19 |     /**
20 |      * Update the model provided with the given data.
21 |      *
22 |      * @param ModelInterface $model
23 |      * @param BagInterface   $data
24 |      *
25 |      * @return \Enzyme\Axiom\Models\ModelInterface
26 |      */
27 |     public function update(ModelInterface $model, BagInterface $data);
28 | }
29 | 


--------------------------------------------------------------------------------
/src/Recipients/OnUpdateRecipientInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Recipients;
 4 | 
 5 | use Enzyme\Axiom\Models\ModelInterface;
 6 | use Enzyme\Axiom\Reports\ReportInterface;
 7 | 
 8 | interface OnUpdateRecipientInterface
 9 | {
10 |     /**
11 |      * Called when the modification of a model was a success.
12 |      *
13 |      * @param ModelInterface $model The updated model.
14 |      *
15 |      * @return mixed
16 |      */
17 |     public function onUpdateSuccess(ModelInterface $model);
18 | 
19 |     /**
20 |      * Called when the modification of a model was a failure.
21 |      *
22 |      * @param ReportInterface $report The failure report.
23 |      *
24 |      * @return mixed
25 |      */
26 |     public function onUpdateFailure(ReportInterface $report);
27 | }
28 | 


--------------------------------------------------------------------------------
/src/Recipients/OnDeleteRecipientInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Recipients;
 4 | 
 5 | use Enzyme\Axiom\Models\ModelInterface;
 6 | use Enzyme\Axiom\Reports\ReportInterface;
 7 | 
 8 | interface OnDeleteRecipientInterface
 9 | {
10 |     /**
11 |      * Called when the deletion of a model was a success.
12 |      *
13 |      * @param ModelInterface $model A shell copy of the deleted model.
14 |      *
15 |      * @return mixed
16 |      */
17 |     public function onDeleteSuccess(ModelInterface $model);
18 | 
19 |     /**
20 |      * Called when the deletion of a model was a failure.
21 |      *
22 |      * @param ReportInterface $report The failure report.
23 |      *
24 |      * @return mixed
25 |      */
26 |     public function onDeleteFailure(ReportInterface $report);
27 | }
28 | 


--------------------------------------------------------------------------------
/console/Commands/MakeModelCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Console\Commands;
 4 | 
 5 | use Symfony\Component\Console\Input\InputArgument;
 6 | use Symfony\Component\Console\Input\InputInterface;
 7 | use Symfony\Component\Console\Output\OutputInterface;
 8 | 
 9 | class MakeModelCommand extends BaseCommand
10 | {
11 |     /**
12 |      * {@inheritDoc}
13 |      */
14 |     protected function getGeneratorType()
15 |     {
16 |         return 'model';
17 |     }
18 | 
19 |     /**
20 |      * {@inheritDoc}
21 |      */
22 |     protected function execute(InputInterface $input, OutputInterface $output)
23 |     {
24 |         parent::execute($input, $output);
25 | 
26 |         $dont_affix_type = true;
27 |         $this->executeGeneration($input, $output, $dont_affix_type);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/src/Models/ModelInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Models;
 4 | 
 5 | interface ModelInterface
 6 | {
 7 |     /**
 8 |      * Get the unique identity for this mode.
 9 |      *
10 |      * @return int
11 |      */
12 |     public function identity();
13 | 
14 |     /**
15 |      * Checks whether this model has the given attribute set.
16 |      *
17 |      * @param string $attribute
18 |      *
19 |      * @return boolean
20 |      */
21 |     public function has($attribute);
22 | 
23 |     /**
24 |      * Get the value associated with the given attribute.
25 |      *
26 |      * @param string $attribute
27 |      *
28 |      * @return mixed
29 |      */
30 |     public function get($attribute);
31 | 
32 |     /**
33 |      * Get all the attributes associated with this model.
34 |      *
35 |      * @return array
36 |      */
37 |     public function getAll();
38 | }
39 | 


--------------------------------------------------------------------------------
/tests/Atoms/StringAtomTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Enzyme\Axiom\Atoms\StringAtom;
 4 | 
 5 | class StringAtomTest extends PHPUnit_Framework_TestCase
 6 | {
 7 |     public function test_atom_stores_correct_base_value()
 8 |     {
 9 |         $expected = 'Foo Bar';
10 |         $atom = new StringAtom($expected);
11 |         $this->assertEquals($expected, $atom->getValue());
12 | 
13 |         $expected = '25';
14 |         $atom = new StringAtom($expected);
15 |         $this->assertEquals($expected, $atom->getValue());
16 | 
17 |         $expected = '';
18 |         $atom = new StringAtom($expected);
19 |         $this->assertEquals($expected, $atom->getValue());
20 |     }
21 | 
22 |     /**
23 |      * @expectedException \Enzyme\Axiom\Exceptions\AtomException
24 |      */
25 |     public function test_atom_throws_exception_when_initialised_with_invalid_value()
26 |     {
27 |         new StringAtom(5);
28 |     }
29 | }
30 | 


--------------------------------------------------------------------------------
/console/Stubs/repository.stub:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace %namespace%;
 4 | 
 5 | use Enzyme\Axiom\Bags\BagInterface;
 6 | use Enzyme\Axiom\Atoms\AtomInterface;
 7 | use Enzyme\Axiom\Models\ModelInterface;
 8 | use Enzyme\Axiom\Factories\FactoryInterface;
 9 | use Enzyme\Axiom\Repositories\RepositoryInterface;
10 | 
11 | class %name%Repository implements RepositoryInterface
12 | {
13 |     protected $factory;
14 | 
15 |     public function __construct(FactoryInterface $factory)
16 |     {
17 |         $this->factory = $factory;
18 |     }
19 | 
20 |     public function add(ModelInterface $model)
21 |     {
22 |         //
23 |     }
24 | 
25 |     public function removeById(AtomInterface $id)
26 |     {
27 |         //
28 |     }
29 | 
30 |     public function update(ModelInterface $model, BagInterface $data)
31 |     {
32 |         //
33 |     }
34 | 
35 |     public function getById(AtomInterface $id)
36 |     {
37 |         //
38 |     }
39 | 
40 |     public function getAll()
41 |     {
42 |         //
43 |     }
44 | 
45 |     public function has(AtomInterface $id)
46 |     {
47 |         //
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/Bags/ArrayBagTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Enzyme\Axiom\Bags\ArrayBag;
 4 | 
 5 | class ArrayBagTest extends PHPUnit_Framework_TestCase
 6 | {
 7 |     public function test_bag_stores_value_as_expected()
 8 |     {
 9 |         $expected = 'Bar';
10 |         $bag = new ArrayBag(['foo' => $expected]);
11 |         $this->assertEquals($expected, $bag->get('foo'));
12 |     }
13 | 
14 |     public function test_bag_returns_null_for_unknown_key()
15 |     {
16 |         $expected = null;
17 |         $bag = new ArrayBag(['foo' => 'bar']);
18 |         $this->assertEquals($expected, $bag->get('PHP'));
19 |     }
20 | 
21 |     public function test_bag_stores_values_as_expected()
22 |     {
23 |         $expected = ['foo' => 'Bar', 'PHP' => 'Rulez'];
24 |         $bag = new ArrayBag($expected);
25 |         $this->assertEquals($expected, $bag->getAll());
26 |     }
27 | 
28 |     public function test_bag_reports_stored_value_as_expected()
29 |     {
30 |         $expected = true;
31 |         $bag = new ArrayBag(['foo' => 'bar']);
32 |         $this->assertEquals($expected, $bag->has('foo'));
33 |     }
34 | }
35 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "enzyme/axiom",
 3 |     "type": "library",
 4 |     "description": "A set of interfaces & classes for creating domain driven projects.",
 5 |     "keywords": ["enzyme","axiom","interfaces","ddd","hex","php"],
 6 |     "homepage": "https://github.com/enzyme/axiom",
 7 |     "license": "MIT",
 8 |     "bin": ["bin/axiom"],
 9 |     "authors": [
10 |         {
11 |             "name": "Tristan Strathearn",
12 |             "email": "r3oath@gmail.com",
13 |             "homepage": "https://github.com/r3oath",
14 |             "role": "Senior Web Developer"
15 |         }
16 |     ],
17 |     "require": {
18 |         "php": ">=5.5.0",
19 |         "symfony/console": "^3.0",
20 |         "enzyme/parrot": "^0.0.1",
21 |         "icanboogie/inflector": "^1.4",
22 |         "enzyme/freckle": "^0.3.0"
23 |     },
24 |     "autoload": {
25 |         "psr-4": {
26 |             "Enzyme\\Axiom\\": "src/",
27 |             "Enzyme\\Axiom\\Console\\": "console/"
28 |         }
29 |     },
30 |     "require-dev": {
31 |         "phpunit/phpunit": "^4.8",
32 |         "mockery/mockery": "^0.9.4",
33 |         "satooshi/php-coveralls": "^0.6.1"
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/Atoms/IntegerAtomTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Enzyme\Axiom\Atoms\IntegerAtom;
 4 | 
 5 | class IntegerAtomTest extends PHPUnit_Framework_TestCase
 6 | {
 7 |     public function test_atom_stores_correct_base_value()
 8 |     {
 9 |         $expected = 5;
10 |         $atom = new IntegerAtom($expected);
11 |         $this->assertEquals($expected, $atom->getValue());
12 | 
13 |         $expected = 25;
14 |         $atom = new IntegerAtom($expected);
15 |         $this->assertEquals($expected, $atom->getValue());
16 | 
17 |         $expected = PHP_INT_MAX;
18 |         $atom = new IntegerAtom($expected);
19 |         $this->assertEquals($expected, $atom->getValue());
20 |     }
21 | 
22 |     /**
23 |      * @expectedException \Enzyme\Axiom\Exceptions\AtomException
24 |      */
25 |     public function test_atom_throws_exception_when_initialised_with_invalid_value()
26 |     {
27 |         new IntegerAtom('foobar');
28 |     }
29 | 
30 |     /**
31 |      * @expectedException \Enzyme\Axiom\Exceptions\AtomException
32 |      */
33 |     public function test_atom_throws_exception_when_initialised_with_floating_value()
34 |     {
35 |         new IntegerAtom(100.5);
36 |     }
37 | }
38 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Tristan Strathearn <r3oath@protonmail.com>
 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 | 


--------------------------------------------------------------------------------
/tests/Reports/SimpleReportTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Enzyme\Axiom\Reports\SimpleReport;
 4 | 
 5 | class SimpleReportTest extends PHPUnit_Framework_TestCase
 6 | {
 7 |     public function test_report_stores_message_as_expected()
 8 |     {
 9 |         $expected = 'Something went wrong.';
10 |         $report = new SimpleReport($expected);
11 |         $this->assertEquals($expected, $report->getMessage());
12 |     }
13 | 
14 |     public function test_report_stores_details_as_expected()
15 |     {
16 |         $expected = ['tests' => 'required'];
17 |         $report = new SimpleReport('Foo Bar went pear shaped.', $expected);
18 |         $this->assertEquals($expected, $report->getDetails());
19 |     }
20 | 
21 |     public function test_report_reports_details_as_expected()
22 |     {
23 |         $expected = true;
24 |         $report = new SimpleReport(
25 |             'It went pear shaped again.', ['tests' => 'required']
26 |         );
27 |         $this->assertEquals($expected, $report->hasDetails());
28 | 
29 |         $expected = false;
30 |         $report = new SimpleReport('Foo Bar went pear shaped.');
31 |         $this->assertEquals($expected, $report->hasDetails());
32 |     }
33 | }
34 | 


--------------------------------------------------------------------------------
/src/Repositories/InMemoryRepository.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Repositories;
 4 | 
 5 | use Enzyme\Axiom\Bags\BagInterface;
 6 | use Enzyme\Axiom\Atoms\AtomInterface;
 7 | use Enzyme\Axiom\Models\ModelInterface;
 8 | use Enzyme\Axiom\Factories\FactoryInterface;
 9 | 
10 | class InMemoryRepository implements RepositoryInterface
11 | {
12 |     protected $factory;
13 |     protected $store;
14 | 
15 |     public function __construct(FactoryInterface $factory)
16 |     {
17 |         $this->factory = $factory;
18 |         $this->store = [];
19 |     }
20 | 
21 |     public function add(ModelInterface $model)
22 |     {
23 |         $this->store[$model->identity()] = $model;
24 |     }
25 | 
26 |     public function removeById(AtomInterface $id)
27 |     {
28 |         if ($this->has($id)) {
29 |             unset($this->store[$id->getValue()]);
30 |         }
31 |     }
32 | 
33 |     public function update(ModelInterface $model, BagInterface $data)
34 |     {
35 |         $updated_model = $this->factory->update($model, $data);
36 |         $this->store[$model->identity()] = $updated_model;
37 |     }
38 | 
39 |     public function getById(AtomInterface $id)
40 |     {
41 |         return $this->has($id)
42 |              ? $this->store[$id->getValue()]
43 |              : null;
44 |     }
45 | 
46 |     public function getAll()
47 |     {
48 |         return $this->store;
49 |     }
50 | 
51 |     public function has(AtomInterface $id)
52 |     {
53 |         return isset($this->store[$id->getValue()])
54 |             && array_key_exists($id->getValue(), $this->store);
55 |     }
56 | }
57 | 


--------------------------------------------------------------------------------
/src/Repositories/RepositoryInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Repositories;
 4 | 
 5 | use Enzyme\Axiom\Bags\BagInterface;
 6 | use Enzyme\Axiom\Atoms\AtomInterface;
 7 | use Enzyme\Axiom\Models\ModelInterface;
 8 | 
 9 | interface RepositoryInterface
10 | {
11 |     /**
12 |      * Add the given model to the repository.
13 |      *
14 |      * @param ModelInterface $model
15 |      */
16 |     public function add(ModelInterface $model);
17 | 
18 |     /**
19 |      * Remove the model with the given ID from the repository.
20 |      *
21 |      * @param AtomInterface $id
22 |      *
23 |      * @return void
24 |      */
25 |     public function removeById(AtomInterface $id);
26 | 
27 |     /**
28 |      * Update the given model with the supplied data.
29 |      *
30 |      * @param ModelInterface $model
31 |      * @param BagInterface   $data
32 |      *
33 |      * @return \Enzyme\Axiom\Models\ModelInterface
34 |      */
35 |     public function update(ModelInterface $model, BagInterface $data);
36 | 
37 |     /**
38 |      * Get the model associated with the given ID.
39 |      *
40 |      * @param AtomInterface $id
41 |      *
42 |      * @return \Enzyme\Axiom\Models\ModelInterface
43 |      */
44 |     public function getById(AtomInterface $id);
45 | 
46 |     /**
47 |      * Get all models from this repository.
48 |      *
49 |      * @return array
50 |      */
51 |     public function getAll();
52 | 
53 |     /**
54 |      * Check whether this repository has a model associated with the given ID.
55 |      *
56 |      * @param AtomInterface $id
57 |      *
58 |      * @return boolean
59 |      */
60 |     public function has(AtomInterface $id);
61 | }
62 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <phpunit
 2 |     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 3 |     xsi:noNamespaceSchemaLocation="http://schema.phpunit.de/4.5/phpunit.xsd"
 4 |     backupGlobals="true"
 5 |     backupStaticAttributes="false"
 6 |     bootstrap="vendor/autoload.php"
 7 |     cacheTokens="false"
 8 |     colors="true"
 9 |     convertErrorsToExceptions="true"
10 |     convertNoticesToExceptions="true"
11 |     convertWarningsToExceptions="true"
12 |     forceCoversAnnotation="false"
13 |     mapTestClassNameToCoveredClassName="false"
14 |     printerClass="PHPUnit_TextUI_ResultPrinter"
15 |     processIsolation="false"
16 |     stopOnError="false"
17 |     stopOnFailure="false"
18 |     stopOnIncomplete="false"
19 |     stopOnSkipped="false"
20 |     stopOnRisky="false"
21 |     testSuiteLoaderClass="PHPUnit_Runner_StandardTestSuiteLoader"
22 |     timeoutForSmallTests="1"
23 |     timeoutForMediumTests="10"
24 |     timeoutForLargeTests="60"
25 |     verbose="true">
26 |     <logging>
27 |         <log type="coverage-clover" target="build/logs/clover.xml"/>
28 |     </logging>
29 |     <filter>
30 |         <whitelist processUncoveredFilesFromWhitelist="true">
31 |             <directory suffix=".php">src</directory>
32 |         </whitelist>
33 |     </filter>
34 |     <filter>
35 |         <whitelist processUncoveredFilesFromWhitelist="true">
36 |             <directory suffix=".php">console</directory>
37 |         </whitelist>
38 |     </filter>
39 |     <testsuites>
40 |         <testsuite name="Console Test Suite">
41 |             <directory>tests/Console</directory>
42 |         </testsuite>
43 |         <testsuite name="Atoms Test Suite">
44 |             <directory>tests/Atoms</directory>
45 |         </testsuite>
46 |         <testsuite name="Bags Test Suite">
47 |             <directory>tests/Bags</directory>
48 |         </testsuite>
49 |         <testsuite name="Reports Test Suite">
50 |             <directory>tests/Reports</directory>
51 |         </testsuite>
52 |         <testsuite name="Repositories Test Suite">
53 |             <directory>tests/Repositories</directory>
54 |         </testsuite>
55 |     </testsuites>
56 | </phpunit>
57 | 


--------------------------------------------------------------------------------
/console/Commands/MakeStackCommand.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Console\Commands;
 4 | 
 5 | use Symfony\Component\Console\Input\ArrayInput;
 6 | use Symfony\Component\Console\Input\InputOption;
 7 | use Symfony\Component\Console\Input\InputArgument;
 8 | use Symfony\Component\Console\Input\InputInterface;
 9 | use Symfony\Component\Console\Output\OutputInterface;
10 | 
11 | class MakeStackCommand extends BaseCommand
12 | {
13 |     /**
14 |      * {@inheritDoc}
15 |      */
16 |     protected function getGeneratorType()
17 |     {
18 |         return 'stack';
19 |     }
20 | 
21 |     /**
22 |      * {@inheritDoc}
23 |      */
24 |     protected function configure()
25 |     {
26 |         $generator_type = $this->getGeneratorType();
27 | 
28 |         $this
29 |             ->setName("make:{$generator_type}")
30 |             ->setDescription("Make a new resource stack.")
31 |             ->addArgument(
32 |                 'name',
33 |                 InputArgument::REQUIRED,
34 |                 "The name to prefix on every generated class, eg: \"user\"."
35 |             )
36 |             ->addOption(
37 |                 'ignore',
38 |                 null,
39 |                 InputOption::VALUE_REQUIRED,
40 |                 'A comma separated list of class types to ignore.'
41 |             );
42 |     }
43 | 
44 |     /**
45 |      * {@inheritDoc}
46 |      */
47 |     protected function execute(InputInterface $input, OutputInterface $output)
48 |     {
49 |         $ignore_list = [];
50 |         $ignore = $input->getOption('ignore');
51 |         if (null !== $ignore) {
52 |             $ignore_list = array_flip(explode(',', $ignore));
53 |         }
54 | 
55 |         $classes = [
56 |             'bag', 'factory', 'model', 'repository',
57 |         ];
58 | 
59 |         $name = $input->getArgument('name');
60 |         foreach ($classes as $class) {
61 |             if (isset($ignore_list[$class]) === true) {
62 |                 continue;
63 |             }
64 | 
65 |             $command = $this->getApplication()->find("make:{$class}");
66 |             $arguments = array(
67 |                 'name' => $name,
68 |             );
69 |             $input = new ArrayInput($arguments);
70 |             $command->run($input, $output);
71 |         }
72 |     }
73 | }
74 | 


--------------------------------------------------------------------------------
/console/Stubs/Manager.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Enzyme\Axiom\Console\Stubs;
 4 | 
 5 | use Enzyme\Parrot\File;
 6 | 
 7 | class Manager
 8 | {
 9 |     /**
10 |      * The location of the stubs directory.
11 |      *
12 |      * @var string
13 |      */
14 |     protected $stubs_dir;
15 | 
16 |     /**
17 |      * An instance of a parrot file wrapper.
18 |      *
19 |      * @var \Enzyme\Parrot\File
20 |      */
21 |     protected $file_dispatch;
22 | 
23 |     /**
24 |      * Create a new stub manager.
25 |      *
26 |      * @param \Enzyme\Parrot\File $file_dispatch
27 |      */
28 |     public function __construct(File $file_dispatch)
29 |     {
30 |         $this->stubs_dir = __DIR__ . '/';
31 |         $this->file_dispatch = $file_dispatch;
32 |     }
33 | 
34 |     /**
35 |      * Get the contents for the provided stub.
36 |      *
37 |      * @param string $stub
38 |      *
39 |      * @return string
40 |      *
41 |      * @throws InvalidArgumentException If the stub by the given name does not
42 |      * exist in the `console/Stubs` folder using the format `{name}.stub`.
43 |      */
44 |     public function get($stub)
45 |     {
46 |         $file = $this->stubs_dir . $stub . '.stub';
47 | 
48 |         if (false === $this->file_dispatch->exists($file)) {
49 |             throw new InvalidArgumentException(
50 |                 "The stub [$stub] does not exist"
51 |             );
52 |         }
53 | 
54 |         return $this->file_dispatch->getContents($file);
55 |     }
56 | 
57 |     /**
58 |      * Hydrate the given contents, replacing the given keys with the values
59 |      * provided in the associative array.
60 |      *
61 |      * @param string $contents
62 |      * @param array  $data
63 |      *
64 |      * @return string
65 |      */
66 |     public function hydrate($contents, array $data)
67 |     {
68 |         foreach ($data as $key => $value) {
69 |             $contents = str_replace('%' . $key . '%', $value, $contents);
70 |         }
71 | 
72 |         return $contents;
73 |     }
74 | 
75 |     /**
76 |      * Write the given contents out to the specified file.
77 |      *
78 |      * @param string $contents
79 |      * @param string $path
80 |      */
81 |     public function writeOut($contents, $path)
82 |     {
83 |         $this->file_dispatch->putContents($path, $contents);
84 |     }
85 | }
86 | 


--------------------------------------------------------------------------------
/bin/axiom:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env php
 2 | <?php
 3 | 
 4 | // A collection of locations where the composer autoload file may be present
 5 | // relative to our current working directory.
 6 | $autoload_locations = [
 7 |     __DIR__.'/../autoload.php',
 8 |     __DIR__.'/../../../autoload.php',
 9 |     __DIR__.'/../vendor/autoload.php',
10 | ];
11 | 
12 | // A collection of locations where the axiom configuration file may be
13 | // present relative to our current working directory.
14 | $axiom_yaml_locations = [
15 |     __DIR__.'/../axiom.yaml',
16 |     __DIR__.'/../../axiom.yaml',
17 |     __DIR__.'/../../../../axiom.yaml',
18 | ];
19 | 
20 | // If we find a composer autoload file, set the location as a global constant,
21 | // otherwise fail and notify the user.
22 | foreach ($autoload_locations as $file) {
23 |     if (file_exists($file) === true) {
24 |         define('COMPOSER_AUTOLOAD_LOCATION', $file);
25 |         break;
26 |     }
27 | }
28 | if (false === defined('COMPOSER_AUTOLOAD_LOCATION')) {
29 |     throw new \Exception('Composer autoload.php could not be found.');
30 | }
31 | 
32 | // If we find an axiom configuration file, set the location as a global
33 | // constant, otherwise silently continue on.
34 | foreach ($axiom_yaml_locations as $file) {
35 |     if (file_exists($file) === true) {
36 |         define('AXIOM_YAML_LOCATION', $file);
37 |         break;
38 |     }
39 | }
40 | if (false === defined('AXIOM_YAML_LOCATION')) {
41 |     define('AXIOM_YAML_LOCATION', '');
42 | }
43 | 
44 | require_once COMPOSER_AUTOLOAD_LOCATION;
45 | 
46 | use Enzyme\Parrot\File;
47 | use Enzyme\Freckle\Dot;
48 | use Enzyme\Axiom\Console\Config;
49 | use Enzyme\Axiom\Console\Commands;
50 | use Symfony\Component\Yaml\Parser;
51 | use Symfony\Component\Console\Application;
52 | use Enzyme\Axiom\Console\Stubs\Manager as StubManager;
53 | 
54 | $parser = new Parser;
55 | $config = new Config($parser, new File, new Dot);
56 | $stub_manager = new StubManager(new File);
57 | 
58 | $config->parse(AXIOM_YAML_LOCATION);
59 | 
60 | $application = new Application();
61 | $application->add(new Commands\MakeBagCommand($stub_manager, $config));
62 | $application->add(new Commands\MakeAtomCommand($stub_manager, $config));
63 | $application->add(new Commands\MakeModelCommand($stub_manager, $config));
64 | $application->add(new Commands\MakeStackCommand($stub_manager, $config));
65 | $application->add(new Commands\MakeReportCommand($stub_manager, $config));
66 | $application->add(new Commands\MakeFactoryCommand($stub_manager, $config));
67 | $application->add(new Commands\MakeRepositoryCommand($stub_manager, $config));
68 | $application->run();
69 | 


--------------------------------------------------------------------------------
/console/Config.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Enzyme\Axiom\Console;
  4 | 
  5 | use Enzyme\Parrot\File;
  6 | use Enzyme\Freckle\Dot;
  7 | use Symfony\Component\Yaml\Parser;
  8 | use Symfony\Component\Yaml\Exception\ParseException;
  9 | 
 10 | class Config
 11 | {
 12 |     /**
 13 |      * Reference to the Symfony YAML parser.
 14 |      *
 15 |      * @var \Symfony\Component\Yaml\Parser
 16 |      */
 17 |     protected $parser;
 18 | 
 19 |     /**
 20 |      * Reference to a parrot file wrapper.
 21 |      *
 22 |      * @var \Enzyme\Parrot\File
 23 |      */
 24 |     protected $file_dispatch;
 25 | 
 26 |     /**
 27 |      * The parsed YAML configuration.
 28 |      *
 29 |      * @var array
 30 |      */
 31 |     protected $config;
 32 | 
 33 |     /**
 34 |      * The dot array accessor.
 35 |      *
 36 |      * @var \Enzyme\Freckle\Dot
 37 |      */
 38 |     protected $dot;
 39 | 
 40 |     /**
 41 |      * Create a new configuration manager.
 42 |      *
 43 |      * @param \Symfony\Component\Yaml\Parser $parser
 44 |      * @param \Enzyme\Parrot\File            $file_dispatch
 45 |      * @param \Enzyme\Freckle\Dot            $dot
 46 |      */
 47 |     public function __construct(Parser $parser, File $file_dispatch, Dot $dot)
 48 |     {
 49 |         $this->parser = $parser;
 50 |         $this->file_dispatch = $file_dispatch;
 51 |         $this->dot = $dot;
 52 |         $this->config = [];
 53 |     }
 54 | 
 55 |     /**
 56 |      * Parse the given YAML file.
 57 |      *
 58 |      * @param string $file The path to the file.
 59 |      *
 60 |      * @throws Exception If the YAML file cannot be parsed.
 61 |      */
 62 |     public function parse($file)
 63 |     {
 64 |         if (false === $this->file_dispatch->exists($file)) {
 65 |             return;
 66 |         }
 67 | 
 68 |         try {
 69 |             $results = $this->parser->parse(
 70 |                 $this->file_dispatch->getContents($file)
 71 |             );
 72 | 
 73 |             if (true === is_array($results)) {
 74 |                 $this->config = $results;
 75 |             }
 76 |         } catch (ParseException $e) {
 77 |             throw new Exception(
 78 |                 "The yaml configuration file [$file] is invalid."
 79 |             );
 80 |         }
 81 |     }
 82 | 
 83 |     /**
 84 |      * Get the value associated with the given key, if the key does not
 85 |      * exist, return null.
 86 |      *
 87 |      * @param string $key
 88 |      *
 89 |      * @return null|string
 90 |      */
 91 |     public function get($key)
 92 |     {
 93 |         if (count($this->config) < 1) {
 94 |             return null;
 95 |         }
 96 | 
 97 |         return $this->dot->get($this->config, $key);
 98 |     }
 99 | }
100 | 


--------------------------------------------------------------------------------
/tests/Console/ConfigTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Mockery as m;
 4 | use Enzyme\Freckle\Dot;
 5 | use Enzyme\Axiom\Console\Config;
 6 | use Symfony\Component\Yaml\Parser;
 7 | 
 8 | class ConfigTest extends PHPUnit_Framework_TestCase
 9 | {
10 |     public function tearDown()
11 |     {
12 |         m::close();
13 |     }
14 | 
15 |     public function test_config_returns_early_when_file_does_not_exist()
16 |     {
17 |         $file = 'fake.yaml';
18 |         $file_dispatch = m::mock(
19 |             'Enzyme\Parrot\File[exists]',
20 |             function($mock) use($file) {
21 |                 $mock
22 |                     ->shouldReceive('exists')
23 |                     ->with($file)
24 |                     ->times(1)
25 |                     ->andReturn(false);
26 |             }
27 |         );
28 | 
29 |         $config = new Config(new Parser, $file_dispatch, new Dot);
30 |         $config->parse($file);
31 |     }
32 | 
33 |     public function test_config_stores_correct_values_from_valid_yaml_file()
34 |     {
35 |         $file = 'fake.yaml';
36 |         $contents = "repositories:\n";
37 |         $contents .= "    - location: ~/Code/Acme/src/Repos\n";
38 |         $contents .= "    - namespace: Acme\Repos\n";
39 |         $file_dispatch = m::mock(
40 |             'Enzyme\Parrot\File[exists,getContents]',
41 |             function($mock) use($file, $contents) {
42 |                 $mock
43 |                     ->shouldReceive('exists')
44 |                     ->with($file)
45 |                     ->times(1)
46 |                     ->andReturn(true);
47 |                 $mock
48 |                     ->shouldReceive('getContents')
49 |                     ->with($file)
50 |                     ->times(1)
51 |                     ->andReturn($contents);
52 |             }
53 |         );
54 | 
55 |         $config = new Config(new Parser, $file_dispatch, new Dot);
56 |         $config->parse($file);
57 |         $expected = '~/Code/Acme/src/Repos';
58 |         $actual = $config->get('repositories.location');
59 | 
60 |         $this->assertEquals($expected, $actual);
61 |     }
62 | 
63 |     /**
64 |      * @expectedException InvalidArgumentException
65 |      */
66 |     public function test_config_throws_exception_on_bad_yaml_parse()
67 |     {
68 |         $file = 'fake.yaml';
69 |         $parser = m::mock(
70 |             'Symfony\Component\Yaml\Parser[parse]',
71 |             function($mock) {
72 |                 $mock
73 |                     ->shouldReceive('parse')
74 |                     ->andThrow(new InvalidArgumentException('oops'));
75 |             }
76 |         );
77 |         $file_dispatch = m::mock(
78 |             'Enzyme\Parrot\File[exists,getContents]',
79 |             function($mock) use($file) {
80 |                 $mock
81 |                     ->shouldReceive('exists')
82 |                     ->with($file)
83 |                     ->times(1)
84 |                     ->andReturn(true);
85 |                 $mock
86 |                     ->shouldReceive('getContents')
87 |                     ->with($file)
88 |                     ->times(1)
89 |                     ->andReturn('bad');
90 |             }
91 |         );
92 | 
93 |         $config = new Config($parser, $file_dispatch, new Dot);
94 |         $config->parse($file);
95 |     }
96 | }
97 | 


--------------------------------------------------------------------------------
/tests/Repositories/InMemoryRepositoryTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Mockery as m;
 4 | use Enzyme\Axiom\Bags\ArrayBag;
 5 | use Enzyme\Axiom\Atoms\IntegerAtom;
 6 | use Enzyme\Axiom\Repositories\InMemoryRepository;
 7 | 
 8 | class InMemoryRepositoryTest extends PHPUnit_Framework_TestCase
 9 | {
10 |     public function tearDown()
11 |     {
12 |         m::close();
13 |     }
14 | 
15 |     public function test_repository_stores_models_as_expected()
16 |     {
17 |         $identity = 0;
18 |         $factory = m::mock('Enzyme\Axiom\Factories\FactoryInterface');
19 |         $model = m::mock('Enzyme\Axiom\Models\ModelInterface', function ($mock) use ($identity) {
20 |             $mock->shouldReceive('identity')->once()->andReturn($identity);
21 |         });
22 | 
23 |         $repo = new InMemoryRepository($factory);
24 |         $repo->add($model);
25 | 
26 |         // Let's make sure the repo reports the new model as existing.
27 |         $expected = true;
28 |         $this->assertEquals($expected, $repo->has(new IntegerAtom($identity)));
29 | 
30 |         // And make sure it returns the new model as expected.
31 |         $expected = $model;
32 |         $this->assertEquals($expected, $repo->getById(new IntegerAtom($identity)));
33 | 
34 |         // And that the new model is the only model currently associated with this repo.
35 |         $expected = [$model];
36 |         $this->assertEquals($expected, $repo->getAll());
37 |     }
38 | 
39 |     public function test_repository_removes_models_as_expected()
40 |     {
41 |         $identity = 0;
42 |         $factory = m::mock('Enzyme\Axiom\Factories\FactoryInterface');
43 |         $model = m::mock('Enzyme\Axiom\Models\ModelInterface', function ($mock) use ($identity) {
44 |             $mock->shouldReceive('identity')->once()->andReturn($identity);
45 |         });
46 | 
47 |         $repo = new InMemoryRepository($factory);
48 |         $repo->add($model);
49 |         $repo->removeById(new IntegerAtom($identity));
50 | 
51 |         // Let's make sure the repo reports the model as non-existent.
52 |         $expected = false;
53 |         $this->assertEquals($expected, $repo->has(new IntegerAtom($identity)));
54 | 
55 |         // And make sure it returns null if the model is requested.
56 |         $expected = null;
57 |         $this->assertEquals($expected, $repo->getById(new IntegerAtom($identity)));
58 | 
59 |         // And that the new model is not currently associated with this repo's collection.
60 |         $expected = [];
61 |         $this->assertEquals($expected, $repo->getAll());
62 |     }
63 | 
64 |     public function test_repository_delegates_updates_to_factory_dependency_as_expected()
65 |     {
66 |         $identity = 0;
67 |         $model = m::mock('Enzyme\Axiom\Models\ModelInterface', function ($mock) use ($identity) {
68 |             $mock->shouldReceive('identity')->andReturn($identity);
69 |         });
70 |         $bag = new ArrayBag([]);
71 |         $factory = m::mock('Enzyme\Axiom\Factories\FactoryInterface', function ($mock) use ($model, $bag) {
72 |             $mock->shouldReceive('update')->once()->with($model, $bag)->andReturn($model);
73 |         });
74 | 
75 |         $repo = new InMemoryRepository($factory);
76 |         $repo->add($model);
77 |         $repo->update($model, $bag);
78 |     }
79 | }
80 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | <img src="https://cloud.githubusercontent.com/assets/2805249/12291425/e1430a16-ba32-11e5-950e-7887df7a75e9.png" width="200">
  2 | 
  3 | [![Build Status](https://travis-ci.org/enzyme/axiom.svg?branch=master)](https://travis-ci.org/enzyme/axiom)
  4 | [![Coverage Status](https://coveralls.io/repos/enzyme/axiom/badge.svg?branch=master&service=github)](https://coveralls.io/github/enzyme/axiom?branch=master)
  5 | [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/enzyme/axiom/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/enzyme/axiom/?branch=master)
  6 | 
  7 | Axiom is a collection of PHP PSR-2 compliant interfaces and classes designed to help you flesh out domain driven projects. Sticking to a framework like Axiom will help keep all your projects consistent in their layout, design and implementation, hopefully making your job (and others working on your code) easier.
  8 | 
  9 | # Installation
 10 | 
 11 | ```bash
 12 | composer require enzyme/axiom
 13 | ```
 14 | 
 15 | # What's included
 16 | 
 17 | #### Atoms
 18 | Atoms are wrappers around native php variable types such as int and string. They are used when a service or class expects one of these values and doesn't want to litter the code with type checks such as `if (is_string($var)) {...}`.
 19 | 
 20 | #### Bags
 21 | Bags are used to carry data around the system, whether from the user, an API or an external service.
 22 | 
 23 | #### Exceptions
 24 | These exceptions are thrown by the collection of concrete classes included when internal errors occur.
 25 | 
 26 | #### Factories
 27 | A factory is responsible for the creation and modification of models. It has intimate knowledge of how a model is built and the various attributes it acquires.
 28 | 
 29 | #### Models
 30 | Models represent objects in your domain. They are unique, have a set of attributes and are the primary resource of your application.
 31 | 
 32 | #### Recipients
 33 | Recipients are parts of your system that require knowledge of when a model is either successfully or unsuccessfully created, updated or destroyed after they have initiated a command.
 34 | 
 35 | #### Reports
 36 | Reports are containers that carry a message and optional details associated with the outcome of some event or action in your domain. For example, when a model failed to be created, a FailureReport can be returned with the details of what went wrong.
 37 | 
 38 | #### Repositories
 39 | Repositories are model collections that allow the system to store and retrieve models from an underlying persistence layer.
 40 | 
 41 | # Concrete classes
 42 | There are a couple concrete classes included with Axiom that you can use straight out of the box. These are:
 43 | 
 44 | #### Atoms
 45 | * IntegerAtom - represents an integer value. This does not include floats.
 46 | * StringAtom - represents a string, either empty or of any size.
 47 | 
 48 | #### Bags
 49 | * ArrayBag - simply stores a collection of key/value pairs using an internal native array.
 50 | 
 51 | #### Reports
 52 | * SimpleReport - provides a basic report implementation that stores a message and optional details.
 53 | * FailureReport - extends the simple report and is purely a more readable means of reporting a failure.
 54 | 
 55 | #### Repositories
 56 | * InMemoryRepository - stores a collection of models in-memory using a simple array.
 57 | 
 58 | # Generators
 59 | 
 60 | Axiom comes with a set of command line generators for quickly creating skeleton implementations of the various interfaces included.
 61 | 
 62 | To use the command line tool, run it from the console at the root of your project as:
 63 | 
 64 | ```bash
 65 | php vendor/bin/axiom list
 66 | ```
 67 | 
 68 | When create a resource using the command line tool, you can either specify the namespace and location of the file using the optional parameters `--location=LOCATION` and `--namespace=NAMESPACE` or using an `axiom.yaml` config file (recommended).
 69 | 
 70 | #### axiom.yaml
 71 | 
 72 | The axiom.yaml file lays out the structure for your generated classes and looks something like:
 73 | 
 74 | ```yaml
 75 | repositories:
 76 |     - namespace: Acme\Repositories
 77 |     - location: /Users/enzyme/code/acme/Repositories
 78 | factories:
 79 |     - namespace: Acme\Factories
 80 |     - location: /Users/enzyme/code/acme/Factories
 81 | bags:
 82 |     - namespace: Acme\Bags
 83 |     - location: /Users/enzyme/code/acme/Bags
 84 | atoms:
 85 |     - namespace: Acme\Atoms
 86 |     - location: /Users/enzyme/code/acme/Atoms
 87 | reports:
 88 |     - namespace: Acme\Reports
 89 |     - location: /Users/enzyme/code/acme/Reports
 90 | models:
 91 |     - namespace: Acme\Models
 92 |     - location: /Users/enzyme/code/acme/Models
 93 | ```
 94 | 
 95 | When generating a class using the command line tool and no entry for the class type is found in the `axiom.yaml` (optional) file or through the command line parameter, an exception will be thrown.
 96 | 
 97 | #### Resource stack
 98 | 
 99 | To create an entire resource stack, which includes a repository, factory, bag and model for a domain resource, you can use the `make:stack` command. This command does not accept namespaces and locations from the command line, so you will need a `axiom.yaml` file present. If you want to use the stack generator but want to ignore one or more of the included generated classes, you can use the `--ignore` parameter. Simply pass the `--ignore` parameter a string with a comma-delimited list of the resource types to ignore, eg: `--ignore="model"` or `--ignore="factory,bag"`.
100 | 
101 | # Contributing
102 | 
103 | Please see `CONTRIBUTING.md`
104 | 
105 | # License
106 | 
107 | MIT - Copyright (c) 2015 Tristan Strathearn, see `LICENSE`
108 | 


--------------------------------------------------------------------------------
/console/Commands/BaseCommand.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | namespace Enzyme\Axiom\Console\Commands;
  4 | 
  5 | use ICanBoogie\Inflector;
  6 | use Enzyme\Axiom\Console\Config;
  7 | use Symfony\Component\Console\Command\Command;
  8 | use Symfony\Component\Console\Input\InputOption;
  9 | use Symfony\Component\Console\Input\InputArgument;
 10 | use Symfony\Component\Console\Input\InputInterface;
 11 | use Symfony\Component\Console\Output\OutputInterface;
 12 | use Enzyme\Axiom\Console\Stubs\Manager as StubManager;
 13 | 
 14 | abstract class BaseCommand extends Command
 15 | {
 16 |     /**
 17 |      * Reference to the stub manager.
 18 |      *
 19 |      * @var \Enzyme\Axiom\Console\Stubs\Manager
 20 |      */
 21 |     protected $stub_manager;
 22 | 
 23 |     /**
 24 |      * The namespace this generated class falls under.
 25 |      *
 26 |      * @var string
 27 |      */
 28 |     protected $namespace;
 29 | 
 30 |     /**
 31 |      * The location this generated class will be saved at.
 32 |      *
 33 |      * @var string
 34 |      */
 35 |     protected $location;
 36 | 
 37 |     /**
 38 |      * The global configuration manager.
 39 |      *
 40 |      * @var \Enzyme\Axiom\Console\Config
 41 |      */
 42 |     protected $config;
 43 | 
 44 |     /**
 45 |      * Instantiate a new command.
 46 |      *
 47 |      * @param \Enzyme\Axiom\Console\Stubs\Manager $stub_manager
 48 |      * @param \Enzyme\Axiom\Console\Config        $config
 49 |      */
 50 |     public function __construct(StubManager $stub_manager, Config $config)
 51 |     {
 52 |         parent::__construct();
 53 | 
 54 |         $this->stub_manager = $stub_manager;
 55 |         $this->config = $config;
 56 |         $this->location = null;
 57 |         $this->namespace = null;
 58 |     }
 59 | 
 60 |     /**
 61 |      * The generator type this class is handling, eg: "factory".
 62 |      *
 63 |      * @return string
 64 |      */
 65 |     abstract protected function getGeneratorType();
 66 | 
 67 |     /**
 68 |      * {@inheritDoc}
 69 |      */
 70 |     protected function configure()
 71 |     {
 72 |         $generator_type = $this->getGeneratorType();
 73 | 
 74 |         $this
 75 |             ->setName("make:{$generator_type}")
 76 |             ->setDescription("Make a new {$generator_type}.")
 77 |             ->addArgument(
 78 |                 'name',
 79 |                 InputArgument::REQUIRED,
 80 |                 "The name prefix on the generated {$generator_type}, eg: \"user\""
 81 |             )
 82 |             ->addOption(
 83 |                 'location',
 84 |                 null,
 85 |                 InputOption::VALUE_REQUIRED,
 86 |                 'The location for the generated file.'
 87 |             )
 88 |             ->addOption(
 89 |                'namespace',
 90 |                null,
 91 |                InputOption::VALUE_REQUIRED,
 92 |                'The namespace to fall under.'
 93 |             );
 94 |     }
 95 | 
 96 |     /**
 97 |      * {@inheritDoc}
 98 |      *
 99 |      * @throws Exception If there is no namespace or location defined for the
100 |      * class type(s) being generated.
101 |      */
102 |     protected function execute(InputInterface $input, OutputInterface $output)
103 |     {
104 |         $inflector = Inflector::get(Inflector::DEFAULT_LOCALE);
105 |         $type_plural = $inflector->pluralize($this->getGeneratorType());
106 | 
107 |         $this->namespace = $input->getOption('namespace') !== null
108 |             ? $input->getOption('namespace')
109 |             : $this->config->get("{$type_plural}.namespace");
110 | 
111 |         $this->location = $input->getOption('location') !== null
112 |             ? $input->getOption('location')
113 |             : $this->config->get("{$type_plural}.location");
114 | 
115 |         if (null === $this->namespace) {
116 |             throw new Exception(
117 |                 "There is no namespace defined for {$type_plural}"
118 |             );
119 |         }
120 | 
121 |         if (null === $this->location) {
122 |             throw new Exception(
123 |                 "There is no location defined for {$type_plural}"
124 |             );
125 |         }
126 |     }
127 | 
128 |     /**
129 |      * Execute a generation command - make a single usuable Axiom class. If
130 |      * $dont_affix_type is true, do not add the class type to the end of the
131 |      * name, this is useful for models which generally are just named as they
132 |      * are and don't have "Model" affixed, eg: "User", not "UserModel".
133 |      *
134 |      * @param \Symfony\Component\Console\Input\InputInterface   $input
135 |      * @param \Symfony\Component\Console\Output\OutputInterface $output
136 |      * @param bool                                              $dont_affix_type
137 |      */
138 |     protected function executeGeneration(
139 |         InputInterface $input,
140 |         OutputInterface $output,
141 |         $dont_affix_type = false
142 |     ) {
143 |         $uc_name = ucfirst($input->getArgument('name'));
144 |         $uc_type = ucfirst($this->getGeneratorType());
145 | 
146 |         $contents = $this->stub_manager->get($this->getGeneratorType());
147 |         $contents = $this->stub_manager->hydrate($contents, [
148 |             'namespace' => $this->namespace,
149 |             'name'      => $uc_name,
150 |         ]);
151 | 
152 |         $out_file = $dont_affix_type === true
153 |             ? "{$this->location}/{$uc_name}.php"
154 |             : "{$this->location}/{$uc_name}{$uc_type}.php";
155 | 
156 |         $this->stub_manager->writeOut($contents, $out_file);
157 | 
158 |         $this->printResults(
159 |             $output,
160 |             $uc_name,
161 |             $dont_affix_type
162 |         );
163 |     }
164 | 
165 |     /**
166 |      * Print the results of the generate operation to the console window.
167 |      *
168 |      * @param \Symfony\Component\Console\Output\OutputInterface $output
169 |      * @param string                                            $name
170 |      * @param bool                                              $dont_affix_type
171 |      */
172 |     protected function printResults(
173 |         OutputInterface $output,
174 |         $name,
175 |         $dont_affix_type = false
176 |     ) {
177 |         $uc_type = ucfirst($this->getGeneratorType());
178 |         $output->writeln("<info>{$uc_type} created for [{$name}]</info>");
179 | 
180 |         $class = $dont_affix_type === true
181 |             ? $name
182 |             : $name . $uc_type;
183 | 
184 |         if (true === $output->isVerbose()) {
185 |             $output->writeln("<comment>    Namespace -> {$this->namespace}</comment>");
186 |             $output->writeln("<comment>        Class -> {$class}</comment>");
187 |             $output->writeln("<comment>     Location -> {$this->location}</comment>");
188 |         }
189 |     }
190 | }
191 | 


--------------------------------------------------------------------------------
/composer.lock:
--------------------------------------------------------------------------------
   1 | {
   2 |     "_readme": [
   3 |         "This file locks the dependencies of your project to a known state",
   4 |         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#composer-lock-the-lock-file",
   5 |         "This file is @generated automatically"
   6 |     ],
   7 |     "hash": "245edbefbdf410efa26b624440d157b0",
   8 |     "content-hash": "b4dceb7f4f8369c20587b86ff1a91cc5",
   9 |     "packages": [
  10 |         {
  11 |             "name": "enzyme/freckle",
  12 |             "version": "v0.3.0",
  13 |             "source": {
  14 |                 "type": "git",
  15 |                 "url": "https://github.com/enzyme/freckle.git",
  16 |                 "reference": "c4782eada4217349a26da2ec277717437a92e39b"
  17 |             },
  18 |             "dist": {
  19 |                 "type": "zip",
  20 |                 "url": "https://api.github.com/repos/enzyme/freckle/zipball/c4782eada4217349a26da2ec277717437a92e39b",
  21 |                 "reference": "c4782eada4217349a26da2ec277717437a92e39b",
  22 |                 "shasum": ""
  23 |             },
  24 |             "require": {
  25 |                 "php": ">=5.5.0"
  26 |             },
  27 |             "require-dev": {
  28 |                 "mockery/mockery": "^0.9.4",
  29 |                 "phpunit/phpunit": "^4.8",
  30 |                 "satooshi/php-coveralls": "^0.6.1"
  31 |             },
  32 |             "type": "library",
  33 |             "autoload": {
  34 |                 "psr-4": {
  35 |                     "Enzyme\\Freckle\\": "src/"
  36 |                 }
  37 |             },
  38 |             "notification-url": "https://packagist.org/downloads/",
  39 |             "license": [
  40 |                 "MIT"
  41 |             ],
  42 |             "authors": [
  43 |                 {
  44 |                     "name": "Tristan Strathearn",
  45 |                     "email": "r3oath@gmail.com",
  46 |                     "homepage": "https://github.com/r3oath",
  47 |                     "role": "Senior Web Developer"
  48 |                 }
  49 |             ],
  50 |             "description": "A collection of dot-based information retrieval helpers... wuh?",
  51 |             "homepage": "https://github.com/enzyme/freckle",
  52 |             "keywords": [
  53 |                 "collections",
  54 |                 "dot",
  55 |                 "enzyme",
  56 |                 "freckle",
  57 |                 "information",
  58 |                 "path",
  59 |                 "retrieval"
  60 |             ],
  61 |             "time": "2016-04-03 05:46:18"
  62 |         },
  63 |         {
  64 |             "name": "enzyme/parrot",
  65 |             "version": "v0.0.1",
  66 |             "source": {
  67 |                 "type": "git",
  68 |                 "url": "https://github.com/enzyme/parrot.git",
  69 |                 "reference": "e20973c6c48ed88eadbbe382e6f039728b4a9282"
  70 |             },
  71 |             "dist": {
  72 |                 "type": "zip",
  73 |                 "url": "https://api.github.com/repos/enzyme/parrot/zipball/e20973c6c48ed88eadbbe382e6f039728b4a9282",
  74 |                 "reference": "e20973c6c48ed88eadbbe382e6f039728b4a9282",
  75 |                 "shasum": ""
  76 |             },
  77 |             "require": {
  78 |                 "php": ">=5.5.0"
  79 |             },
  80 |             "require-dev": {
  81 |                 "mockery/mockery": "^0.9.4",
  82 |                 "phpunit/phpunit": "^4.8"
  83 |             },
  84 |             "type": "library",
  85 |             "autoload": {
  86 |                 "psr-4": {
  87 |                     "Enzyme\\Parrot\\": "src/"
  88 |                 }
  89 |             },
  90 |             "notification-url": "https://packagist.org/downloads/",
  91 |             "license": [
  92 |                 "MIT"
  93 |             ],
  94 |             "authors": [
  95 |                 {
  96 |                     "name": "Tristan Strathearn",
  97 |                     "email": "r3oath@protonmail.ccom",
  98 |                     "homepage": "https://github.com/r3oath",
  99 |                     "role": "Full Stack Developer"
 100 |                 }
 101 |             ],
 102 |             "description": "Mockable native static functions for PHP.",
 103 |             "homepage": "https://github.com/enzyme/parrot",
 104 |             "keywords": [
 105 |                 "enzyme",
 106 |                 "functions",
 107 |                 "mockable",
 108 |                 "parrot",
 109 |                 "php",
 110 |                 "primitives",
 111 |                 "static"
 112 |             ],
 113 |             "time": "2015-12-14 01:16:37"
 114 |         },
 115 |         {
 116 |             "name": "icanboogie/inflector",
 117 |             "version": "v1.4.0",
 118 |             "source": {
 119 |                 "type": "git",
 120 |                 "url": "https://github.com/ICanBoogie/Inflector.git",
 121 |                 "reference": "e19c8df837fdafb3571df4fb94133bb69ccbce81"
 122 |             },
 123 |             "dist": {
 124 |                 "type": "zip",
 125 |                 "url": "https://api.github.com/repos/ICanBoogie/Inflector/zipball/e19c8df837fdafb3571df4fb94133bb69ccbce81",
 126 |                 "reference": "e19c8df837fdafb3571df4fb94133bb69ccbce81",
 127 |                 "shasum": ""
 128 |             },
 129 |             "require": {
 130 |                 "ext-mbstring": "*",
 131 |                 "php": ">=5.3.4"
 132 |             },
 133 |             "type": "library",
 134 |             "autoload": {
 135 |                 "classmap": [
 136 |                     "lib/"
 137 |                 ],
 138 |                 "files": [
 139 |                     "lib/helpers.php"
 140 |                 ]
 141 |             },
 142 |             "notification-url": "https://packagist.org/downloads/",
 143 |             "license": [
 144 |                 "BSD-3-Clause"
 145 |             ],
 146 |             "authors": [
 147 |                 {
 148 |                     "name": "Olivier Laviale",
 149 |                     "email": "olivier.laviale@gmail.com",
 150 |                     "homepage": "http://www.weirdog.com/",
 151 |                     "role": "Developer"
 152 |                 }
 153 |             ],
 154 |             "description": "Multilingual inflector that transforms words from singular to plural, underscore to camel case, and more.",
 155 |             "homepage": "http://icanboogie.org/",
 156 |             "keywords": [
 157 |                 "camelize",
 158 |                 "hyphenate",
 159 |                 "inflect",
 160 |                 "multilingual",
 161 |                 "pluralize",
 162 |                 "singularize",
 163 |                 "underscore"
 164 |             ],
 165 |             "time": "2015-11-03 11:03:27"
 166 |         },
 167 |         {
 168 |             "name": "symfony/console",
 169 |             "version": "v3.0.4",
 170 |             "source": {
 171 |                 "type": "git",
 172 |                 "url": "https://github.com/symfony/console.git",
 173 |                 "reference": "6b1175135bc2a74c08a28d89761272de8beed8cd"
 174 |             },
 175 |             "dist": {
 176 |                 "type": "zip",
 177 |                 "url": "https://api.github.com/repos/symfony/console/zipball/6b1175135bc2a74c08a28d89761272de8beed8cd",
 178 |                 "reference": "6b1175135bc2a74c08a28d89761272de8beed8cd",
 179 |                 "shasum": ""
 180 |             },
 181 |             "require": {
 182 |                 "php": ">=5.5.9",
 183 |                 "symfony/polyfill-mbstring": "~1.0"
 184 |             },
 185 |             "require-dev": {
 186 |                 "psr/log": "~1.0",
 187 |                 "symfony/event-dispatcher": "~2.8|~3.0",
 188 |                 "symfony/process": "~2.8|~3.0"
 189 |             },
 190 |             "suggest": {
 191 |                 "psr/log": "For using the console logger",
 192 |                 "symfony/event-dispatcher": "",
 193 |                 "symfony/process": ""
 194 |             },
 195 |             "type": "library",
 196 |             "extra": {
 197 |                 "branch-alias": {
 198 |                     "dev-master": "3.0-dev"
 199 |                 }
 200 |             },
 201 |             "autoload": {
 202 |                 "psr-4": {
 203 |                     "Symfony\\Component\\Console\\": ""
 204 |                 },
 205 |                 "exclude-from-classmap": [
 206 |                     "/Tests/"
 207 |                 ]
 208 |             },
 209 |             "notification-url": "https://packagist.org/downloads/",
 210 |             "license": [
 211 |                 "MIT"
 212 |             ],
 213 |             "authors": [
 214 |                 {
 215 |                     "name": "Fabien Potencier",
 216 |                     "email": "fabien@symfony.com"
 217 |                 },
 218 |                 {
 219 |                     "name": "Symfony Community",
 220 |                     "homepage": "https://symfony.com/contributors"
 221 |                 }
 222 |             ],
 223 |             "description": "Symfony Console Component",
 224 |             "homepage": "https://symfony.com",
 225 |             "time": "2016-03-16 17:00:50"
 226 |         },
 227 |         {
 228 |             "name": "symfony/polyfill-mbstring",
 229 |             "version": "v1.0.1",
 230 |             "source": {
 231 |                 "type": "git",
 232 |                 "url": "https://github.com/symfony/polyfill-mbstring.git",
 233 |                 "reference": "49ff736bd5d41f45240cec77b44967d76e0c3d25"
 234 |             },
 235 |             "dist": {
 236 |                 "type": "zip",
 237 |                 "url": "https://api.github.com/repos/symfony/polyfill-mbstring/zipball/49ff736bd5d41f45240cec77b44967d76e0c3d25",
 238 |                 "reference": "49ff736bd5d41f45240cec77b44967d76e0c3d25",
 239 |                 "shasum": ""
 240 |             },
 241 |             "require": {
 242 |                 "php": ">=5.3.3"
 243 |             },
 244 |             "suggest": {
 245 |                 "ext-mbstring": "For best performance"
 246 |             },
 247 |             "type": "library",
 248 |             "extra": {
 249 |                 "branch-alias": {
 250 |                     "dev-master": "1.0-dev"
 251 |                 }
 252 |             },
 253 |             "autoload": {
 254 |                 "psr-4": {
 255 |                     "Symfony\\Polyfill\\Mbstring\\": ""
 256 |                 },
 257 |                 "files": [
 258 |                     "bootstrap.php"
 259 |                 ]
 260 |             },
 261 |             "notification-url": "https://packagist.org/downloads/",
 262 |             "license": [
 263 |                 "MIT"
 264 |             ],
 265 |             "authors": [
 266 |                 {
 267 |                     "name": "Nicolas Grekas",
 268 |                     "email": "p@tchwork.com"
 269 |                 },
 270 |                 {
 271 |                     "name": "Symfony Community",
 272 |                     "homepage": "https://symfony.com/contributors"
 273 |                 }
 274 |             ],
 275 |             "description": "Symfony polyfill for the Mbstring extension",
 276 |             "homepage": "https://symfony.com",
 277 |             "keywords": [
 278 |                 "compatibility",
 279 |                 "mbstring",
 280 |                 "polyfill",
 281 |                 "portable",
 282 |                 "shim"
 283 |             ],
 284 |             "time": "2015-11-20 09:19:13"
 285 |         }
 286 |     ],
 287 |     "packages-dev": [
 288 |         {
 289 |             "name": "doctrine/instantiator",
 290 |             "version": "1.0.5",
 291 |             "source": {
 292 |                 "type": "git",
 293 |                 "url": "https://github.com/doctrine/instantiator.git",
 294 |                 "reference": "8e884e78f9f0eb1329e445619e04456e64d8051d"
 295 |             },
 296 |             "dist": {
 297 |                 "type": "zip",
 298 |                 "url": "https://api.github.com/repos/doctrine/instantiator/zipball/8e884e78f9f0eb1329e445619e04456e64d8051d",
 299 |                 "reference": "8e884e78f9f0eb1329e445619e04456e64d8051d",
 300 |                 "shasum": ""
 301 |             },
 302 |             "require": {
 303 |                 "php": ">=5.3,<8.0-DEV"
 304 |             },
 305 |             "require-dev": {
 306 |                 "athletic/athletic": "~0.1.8",
 307 |                 "ext-pdo": "*",
 308 |                 "ext-phar": "*",
 309 |                 "phpunit/phpunit": "~4.0",
 310 |                 "squizlabs/php_codesniffer": "~2.0"
 311 |             },
 312 |             "type": "library",
 313 |             "extra": {
 314 |                 "branch-alias": {
 315 |                     "dev-master": "1.0.x-dev"
 316 |                 }
 317 |             },
 318 |             "autoload": {
 319 |                 "psr-4": {
 320 |                     "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/"
 321 |                 }
 322 |             },
 323 |             "notification-url": "https://packagist.org/downloads/",
 324 |             "license": [
 325 |                 "MIT"
 326 |             ],
 327 |             "authors": [
 328 |                 {
 329 |                     "name": "Marco Pivetta",
 330 |                     "email": "ocramius@gmail.com",
 331 |                     "homepage": "http://ocramius.github.com/"
 332 |                 }
 333 |             ],
 334 |             "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
 335 |             "homepage": "https://github.com/doctrine/instantiator",
 336 |             "keywords": [
 337 |                 "constructor",
 338 |                 "instantiate"
 339 |             ],
 340 |             "time": "2015-06-14 21:17:01"
 341 |         },
 342 |         {
 343 |             "name": "guzzle/guzzle",
 344 |             "version": "v3.9.3",
 345 |             "source": {
 346 |                 "type": "git",
 347 |                 "url": "https://github.com/guzzle/guzzle3.git",
 348 |                 "reference": "0645b70d953bc1c067bbc8d5bc53194706b628d9"
 349 |             },
 350 |             "dist": {
 351 |                 "type": "zip",
 352 |                 "url": "https://api.github.com/repos/guzzle/guzzle3/zipball/0645b70d953bc1c067bbc8d5bc53194706b628d9",
 353 |                 "reference": "0645b70d953bc1c067bbc8d5bc53194706b628d9",
 354 |                 "shasum": ""
 355 |             },
 356 |             "require": {
 357 |                 "ext-curl": "*",
 358 |                 "php": ">=5.3.3",
 359 |                 "symfony/event-dispatcher": "~2.1"
 360 |             },
 361 |             "replace": {
 362 |                 "guzzle/batch": "self.version",
 363 |                 "guzzle/cache": "self.version",
 364 |                 "guzzle/common": "self.version",
 365 |                 "guzzle/http": "self.version",
 366 |                 "guzzle/inflection": "self.version",
 367 |                 "guzzle/iterator": "self.version",
 368 |                 "guzzle/log": "self.version",
 369 |                 "guzzle/parser": "self.version",
 370 |                 "guzzle/plugin": "self.version",
 371 |                 "guzzle/plugin-async": "self.version",
 372 |                 "guzzle/plugin-backoff": "self.version",
 373 |                 "guzzle/plugin-cache": "self.version",
 374 |                 "guzzle/plugin-cookie": "self.version",
 375 |                 "guzzle/plugin-curlauth": "self.version",
 376 |                 "guzzle/plugin-error-response": "self.version",
 377 |                 "guzzle/plugin-history": "self.version",
 378 |                 "guzzle/plugin-log": "self.version",
 379 |                 "guzzle/plugin-md5": "self.version",
 380 |                 "guzzle/plugin-mock": "self.version",
 381 |                 "guzzle/plugin-oauth": "self.version",
 382 |                 "guzzle/service": "self.version",
 383 |                 "guzzle/stream": "self.version"
 384 |             },
 385 |             "require-dev": {
 386 |                 "doctrine/cache": "~1.3",
 387 |                 "monolog/monolog": "~1.0",
 388 |                 "phpunit/phpunit": "3.7.*",
 389 |                 "psr/log": "~1.0",
 390 |                 "symfony/class-loader": "~2.1",
 391 |                 "zendframework/zend-cache": "2.*,<2.3",
 392 |                 "zendframework/zend-log": "2.*,<2.3"
 393 |             },
 394 |             "suggest": {
 395 |                 "guzzlehttp/guzzle": "Guzzle 5 has moved to a new package name. The package you have installed, Guzzle 3, is deprecated."
 396 |             },
 397 |             "type": "library",
 398 |             "extra": {
 399 |                 "branch-alias": {
 400 |                     "dev-master": "3.9-dev"
 401 |                 }
 402 |             },
 403 |             "autoload": {
 404 |                 "psr-0": {
 405 |                     "Guzzle": "src/",
 406 |                     "Guzzle\\Tests": "tests/"
 407 |                 }
 408 |             },
 409 |             "notification-url": "https://packagist.org/downloads/",
 410 |             "license": [
 411 |                 "MIT"
 412 |             ],
 413 |             "authors": [
 414 |                 {
 415 |                     "name": "Michael Dowling",
 416 |                     "email": "mtdowling@gmail.com",
 417 |                     "homepage": "https://github.com/mtdowling"
 418 |                 },
 419 |                 {
 420 |                     "name": "Guzzle Community",
 421 |                     "homepage": "https://github.com/guzzle/guzzle/contributors"
 422 |                 }
 423 |             ],
 424 |             "description": "PHP HTTP client. This library is deprecated in favor of https://packagist.org/packages/guzzlehttp/guzzle",
 425 |             "homepage": "http://guzzlephp.org/",
 426 |             "keywords": [
 427 |                 "client",
 428 |                 "curl",
 429 |                 "framework",
 430 |                 "http",
 431 |                 "http client",
 432 |                 "rest",
 433 |                 "web service"
 434 |             ],
 435 |             "time": "2015-03-18 18:23:50"
 436 |         },
 437 |         {
 438 |             "name": "hamcrest/hamcrest-php",
 439 |             "version": "v1.2.2",
 440 |             "source": {
 441 |                 "type": "git",
 442 |                 "url": "https://github.com/hamcrest/hamcrest-php.git",
 443 |                 "reference": "b37020aa976fa52d3de9aa904aa2522dc518f79c"
 444 |             },
 445 |             "dist": {
 446 |                 "type": "zip",
 447 |                 "url": "https://api.github.com/repos/hamcrest/hamcrest-php/zipball/b37020aa976fa52d3de9aa904aa2522dc518f79c",
 448 |                 "reference": "b37020aa976fa52d3de9aa904aa2522dc518f79c",
 449 |                 "shasum": ""
 450 |             },
 451 |             "require": {
 452 |                 "php": ">=5.3.2"
 453 |             },
 454 |             "replace": {
 455 |                 "cordoval/hamcrest-php": "*",
 456 |                 "davedevelopment/hamcrest-php": "*",
 457 |                 "kodova/hamcrest-php": "*"
 458 |             },
 459 |             "require-dev": {
 460 |                 "phpunit/php-file-iterator": "1.3.3",
 461 |                 "satooshi/php-coveralls": "dev-master"
 462 |             },
 463 |             "type": "library",
 464 |             "autoload": {
 465 |                 "classmap": [
 466 |                     "hamcrest"
 467 |                 ],
 468 |                 "files": [
 469 |                     "hamcrest/Hamcrest.php"
 470 |                 ]
 471 |             },
 472 |             "notification-url": "https://packagist.org/downloads/",
 473 |             "license": [
 474 |                 "BSD"
 475 |             ],
 476 |             "description": "This is the PHP port of Hamcrest Matchers",
 477 |             "keywords": [
 478 |                 "test"
 479 |             ],
 480 |             "time": "2015-05-11 14:41:42"
 481 |         },
 482 |         {
 483 |             "name": "mockery/mockery",
 484 |             "version": "0.9.4",
 485 |             "source": {
 486 |                 "type": "git",
 487 |                 "url": "https://github.com/padraic/mockery.git",
 488 |                 "reference": "70bba85e4aabc9449626651f48b9018ede04f86b"
 489 |             },
 490 |             "dist": {
 491 |                 "type": "zip",
 492 |                 "url": "https://api.github.com/repos/padraic/mockery/zipball/70bba85e4aabc9449626651f48b9018ede04f86b",
 493 |                 "reference": "70bba85e4aabc9449626651f48b9018ede04f86b",
 494 |                 "shasum": ""
 495 |             },
 496 |             "require": {
 497 |                 "hamcrest/hamcrest-php": "~1.1",
 498 |                 "lib-pcre": ">=7.0",
 499 |                 "php": ">=5.3.2"
 500 |             },
 501 |             "require-dev": {
 502 |                 "phpunit/phpunit": "~4.0"
 503 |             },
 504 |             "type": "library",
 505 |             "extra": {
 506 |                 "branch-alias": {
 507 |                     "dev-master": "0.9.x-dev"
 508 |                 }
 509 |             },
 510 |             "autoload": {
 511 |                 "psr-0": {
 512 |                     "Mockery": "library/"
 513 |                 }
 514 |             },
 515 |             "notification-url": "https://packagist.org/downloads/",
 516 |             "license": [
 517 |                 "BSD-3-Clause"
 518 |             ],
 519 |             "authors": [
 520 |                 {
 521 |                     "name": "Pádraic Brady",
 522 |                     "email": "padraic.brady@gmail.com",
 523 |                     "homepage": "http://blog.astrumfutura.com"
 524 |                 },
 525 |                 {
 526 |                     "name": "Dave Marshall",
 527 |                     "email": "dave.marshall@atstsolutions.co.uk",
 528 |                     "homepage": "http://davedevelopment.co.uk"
 529 |                 }
 530 |             ],
 531 |             "description": "Mockery is a simple yet flexible PHP mock object framework for use in unit testing with PHPUnit, PHPSpec or any other testing framework. Its core goal is to offer a test double framework with a succinct API capable of clearly defining all possible object operations and interactions using a human readable Domain Specific Language (DSL). Designed as a drop in alternative to PHPUnit's phpunit-mock-objects library, Mockery is easy to integrate with PHPUnit and can operate alongside phpunit-mock-objects without the World ending.",
 532 |             "homepage": "http://github.com/padraic/mockery",
 533 |             "keywords": [
 534 |                 "BDD",
 535 |                 "TDD",
 536 |                 "library",
 537 |                 "mock",
 538 |                 "mock objects",
 539 |                 "mockery",
 540 |                 "stub",
 541 |                 "test",
 542 |                 "test double",
 543 |                 "testing"
 544 |             ],
 545 |             "time": "2015-04-02 19:54:00"
 546 |         },
 547 |         {
 548 |             "name": "phpdocumentor/reflection-docblock",
 549 |             "version": "2.0.4",
 550 |             "source": {
 551 |                 "type": "git",
 552 |                 "url": "https://github.com/phpDocumentor/ReflectionDocBlock.git",
 553 |                 "reference": "d68dbdc53dc358a816f00b300704702b2eaff7b8"
 554 |             },
 555 |             "dist": {
 556 |                 "type": "zip",
 557 |                 "url": "https://api.github.com/repos/phpDocumentor/ReflectionDocBlock/zipball/d68dbdc53dc358a816f00b300704702b2eaff7b8",
 558 |                 "reference": "d68dbdc53dc358a816f00b300704702b2eaff7b8",
 559 |                 "shasum": ""
 560 |             },
 561 |             "require": {
 562 |                 "php": ">=5.3.3"
 563 |             },
 564 |             "require-dev": {
 565 |                 "phpunit/phpunit": "~4.0"
 566 |             },
 567 |             "suggest": {
 568 |                 "dflydev/markdown": "~1.0",
 569 |                 "erusev/parsedown": "~1.0"
 570 |             },
 571 |             "type": "library",
 572 |             "extra": {
 573 |                 "branch-alias": {
 574 |                     "dev-master": "2.0.x-dev"
 575 |                 }
 576 |             },
 577 |             "autoload": {
 578 |                 "psr-0": {
 579 |                     "phpDocumentor": [
 580 |                         "src/"
 581 |                     ]
 582 |                 }
 583 |             },
 584 |             "notification-url": "https://packagist.org/downloads/",
 585 |             "license": [
 586 |                 "MIT"
 587 |             ],
 588 |             "authors": [
 589 |                 {
 590 |                     "name": "Mike van Riel",
 591 |                     "email": "mike.vanriel@naenius.com"
 592 |                 }
 593 |             ],
 594 |             "time": "2015-02-03 12:10:50"
 595 |         },
 596 |         {
 597 |             "name": "phpspec/prophecy",
 598 |             "version": "v1.5.0",
 599 |             "source": {
 600 |                 "type": "git",
 601 |                 "url": "https://github.com/phpspec/prophecy.git",
 602 |                 "reference": "4745ded9307786b730d7a60df5cb5a6c43cf95f7"
 603 |             },
 604 |             "dist": {
 605 |                 "type": "zip",
 606 |                 "url": "https://api.github.com/repos/phpspec/prophecy/zipball/4745ded9307786b730d7a60df5cb5a6c43cf95f7",
 607 |                 "reference": "4745ded9307786b730d7a60df5cb5a6c43cf95f7",
 608 |                 "shasum": ""
 609 |             },
 610 |             "require": {
 611 |                 "doctrine/instantiator": "^1.0.2",
 612 |                 "phpdocumentor/reflection-docblock": "~2.0",
 613 |                 "sebastian/comparator": "~1.1"
 614 |             },
 615 |             "require-dev": {
 616 |                 "phpspec/phpspec": "~2.0"
 617 |             },
 618 |             "type": "library",
 619 |             "extra": {
 620 |                 "branch-alias": {
 621 |                     "dev-master": "1.4.x-dev"
 622 |                 }
 623 |             },
 624 |             "autoload": {
 625 |                 "psr-0": {
 626 |                     "Prophecy\\": "src/"
 627 |                 }
 628 |             },
 629 |             "notification-url": "https://packagist.org/downloads/",
 630 |             "license": [
 631 |                 "MIT"
 632 |             ],
 633 |             "authors": [
 634 |                 {
 635 |                     "name": "Konstantin Kudryashov",
 636 |                     "email": "ever.zet@gmail.com",
 637 |                     "homepage": "http://everzet.com"
 638 |                 },
 639 |                 {
 640 |                     "name": "Marcello Duarte",
 641 |                     "email": "marcello.duarte@gmail.com"
 642 |                 }
 643 |             ],
 644 |             "description": "Highly opinionated mocking framework for PHP 5.3+",
 645 |             "homepage": "https://github.com/phpspec/prophecy",
 646 |             "keywords": [
 647 |                 "Double",
 648 |                 "Dummy",
 649 |                 "fake",
 650 |                 "mock",
 651 |                 "spy",
 652 |                 "stub"
 653 |             ],
 654 |             "time": "2015-08-13 10:07:40"
 655 |         },
 656 |         {
 657 |             "name": "phpunit/php-code-coverage",
 658 |             "version": "2.2.4",
 659 |             "source": {
 660 |                 "type": "git",
 661 |                 "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
 662 |                 "reference": "eabf68b476ac7d0f73793aada060f1c1a9bf8979"
 663 |             },
 664 |             "dist": {
 665 |                 "type": "zip",
 666 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/eabf68b476ac7d0f73793aada060f1c1a9bf8979",
 667 |                 "reference": "eabf68b476ac7d0f73793aada060f1c1a9bf8979",
 668 |                 "shasum": ""
 669 |             },
 670 |             "require": {
 671 |                 "php": ">=5.3.3",
 672 |                 "phpunit/php-file-iterator": "~1.3",
 673 |                 "phpunit/php-text-template": "~1.2",
 674 |                 "phpunit/php-token-stream": "~1.3",
 675 |                 "sebastian/environment": "^1.3.2",
 676 |                 "sebastian/version": "~1.0"
 677 |             },
 678 |             "require-dev": {
 679 |                 "ext-xdebug": ">=2.1.4",
 680 |                 "phpunit/phpunit": "~4"
 681 |             },
 682 |             "suggest": {
 683 |                 "ext-dom": "*",
 684 |                 "ext-xdebug": ">=2.2.1",
 685 |                 "ext-xmlwriter": "*"
 686 |             },
 687 |             "type": "library",
 688 |             "extra": {
 689 |                 "branch-alias": {
 690 |                     "dev-master": "2.2.x-dev"
 691 |                 }
 692 |             },
 693 |             "autoload": {
 694 |                 "classmap": [
 695 |                     "src/"
 696 |                 ]
 697 |             },
 698 |             "notification-url": "https://packagist.org/downloads/",
 699 |             "license": [
 700 |                 "BSD-3-Clause"
 701 |             ],
 702 |             "authors": [
 703 |                 {
 704 |                     "name": "Sebastian Bergmann",
 705 |                     "email": "sb@sebastian-bergmann.de",
 706 |                     "role": "lead"
 707 |                 }
 708 |             ],
 709 |             "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.",
 710 |             "homepage": "https://github.com/sebastianbergmann/php-code-coverage",
 711 |             "keywords": [
 712 |                 "coverage",
 713 |                 "testing",
 714 |                 "xunit"
 715 |             ],
 716 |             "time": "2015-10-06 15:47:00"
 717 |         },
 718 |         {
 719 |             "name": "phpunit/php-file-iterator",
 720 |             "version": "1.4.1",
 721 |             "source": {
 722 |                 "type": "git",
 723 |                 "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
 724 |                 "reference": "6150bf2c35d3fc379e50c7602b75caceaa39dbf0"
 725 |             },
 726 |             "dist": {
 727 |                 "type": "zip",
 728 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/6150bf2c35d3fc379e50c7602b75caceaa39dbf0",
 729 |                 "reference": "6150bf2c35d3fc379e50c7602b75caceaa39dbf0",
 730 |                 "shasum": ""
 731 |             },
 732 |             "require": {
 733 |                 "php": ">=5.3.3"
 734 |             },
 735 |             "type": "library",
 736 |             "extra": {
 737 |                 "branch-alias": {
 738 |                     "dev-master": "1.4.x-dev"
 739 |                 }
 740 |             },
 741 |             "autoload": {
 742 |                 "classmap": [
 743 |                     "src/"
 744 |                 ]
 745 |             },
 746 |             "notification-url": "https://packagist.org/downloads/",
 747 |             "license": [
 748 |                 "BSD-3-Clause"
 749 |             ],
 750 |             "authors": [
 751 |                 {
 752 |                     "name": "Sebastian Bergmann",
 753 |                     "email": "sb@sebastian-bergmann.de",
 754 |                     "role": "lead"
 755 |                 }
 756 |             ],
 757 |             "description": "FilterIterator implementation that filters files based on a list of suffixes.",
 758 |             "homepage": "https://github.com/sebastianbergmann/php-file-iterator/",
 759 |             "keywords": [
 760 |                 "filesystem",
 761 |                 "iterator"
 762 |             ],
 763 |             "time": "2015-06-21 13:08:43"
 764 |         },
 765 |         {
 766 |             "name": "phpunit/php-text-template",
 767 |             "version": "1.2.1",
 768 |             "source": {
 769 |                 "type": "git",
 770 |                 "url": "https://github.com/sebastianbergmann/php-text-template.git",
 771 |                 "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686"
 772 |             },
 773 |             "dist": {
 774 |                 "type": "zip",
 775 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
 776 |                 "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
 777 |                 "shasum": ""
 778 |             },
 779 |             "require": {
 780 |                 "php": ">=5.3.3"
 781 |             },
 782 |             "type": "library",
 783 |             "autoload": {
 784 |                 "classmap": [
 785 |                     "src/"
 786 |                 ]
 787 |             },
 788 |             "notification-url": "https://packagist.org/downloads/",
 789 |             "license": [
 790 |                 "BSD-3-Clause"
 791 |             ],
 792 |             "authors": [
 793 |                 {
 794 |                     "name": "Sebastian Bergmann",
 795 |                     "email": "sebastian@phpunit.de",
 796 |                     "role": "lead"
 797 |                 }
 798 |             ],
 799 |             "description": "Simple template engine.",
 800 |             "homepage": "https://github.com/sebastianbergmann/php-text-template/",
 801 |             "keywords": [
 802 |                 "template"
 803 |             ],
 804 |             "time": "2015-06-21 13:50:34"
 805 |         },
 806 |         {
 807 |             "name": "phpunit/php-timer",
 808 |             "version": "1.0.7",
 809 |             "source": {
 810 |                 "type": "git",
 811 |                 "url": "https://github.com/sebastianbergmann/php-timer.git",
 812 |                 "reference": "3e82f4e9fc92665fafd9157568e4dcb01d014e5b"
 813 |             },
 814 |             "dist": {
 815 |                 "type": "zip",
 816 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/3e82f4e9fc92665fafd9157568e4dcb01d014e5b",
 817 |                 "reference": "3e82f4e9fc92665fafd9157568e4dcb01d014e5b",
 818 |                 "shasum": ""
 819 |             },
 820 |             "require": {
 821 |                 "php": ">=5.3.3"
 822 |             },
 823 |             "type": "library",
 824 |             "autoload": {
 825 |                 "classmap": [
 826 |                     "src/"
 827 |                 ]
 828 |             },
 829 |             "notification-url": "https://packagist.org/downloads/",
 830 |             "license": [
 831 |                 "BSD-3-Clause"
 832 |             ],
 833 |             "authors": [
 834 |                 {
 835 |                     "name": "Sebastian Bergmann",
 836 |                     "email": "sb@sebastian-bergmann.de",
 837 |                     "role": "lead"
 838 |                 }
 839 |             ],
 840 |             "description": "Utility class for timing",
 841 |             "homepage": "https://github.com/sebastianbergmann/php-timer/",
 842 |             "keywords": [
 843 |                 "timer"
 844 |             ],
 845 |             "time": "2015-06-21 08:01:12"
 846 |         },
 847 |         {
 848 |             "name": "phpunit/php-token-stream",
 849 |             "version": "1.4.8",
 850 |             "source": {
 851 |                 "type": "git",
 852 |                 "url": "https://github.com/sebastianbergmann/php-token-stream.git",
 853 |                 "reference": "3144ae21711fb6cac0b1ab4cbe63b75ce3d4e8da"
 854 |             },
 855 |             "dist": {
 856 |                 "type": "zip",
 857 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-token-stream/zipball/3144ae21711fb6cac0b1ab4cbe63b75ce3d4e8da",
 858 |                 "reference": "3144ae21711fb6cac0b1ab4cbe63b75ce3d4e8da",
 859 |                 "shasum": ""
 860 |             },
 861 |             "require": {
 862 |                 "ext-tokenizer": "*",
 863 |                 "php": ">=5.3.3"
 864 |             },
 865 |             "require-dev": {
 866 |                 "phpunit/phpunit": "~4.2"
 867 |             },
 868 |             "type": "library",
 869 |             "extra": {
 870 |                 "branch-alias": {
 871 |                     "dev-master": "1.4-dev"
 872 |                 }
 873 |             },
 874 |             "autoload": {
 875 |                 "classmap": [
 876 |                     "src/"
 877 |                 ]
 878 |             },
 879 |             "notification-url": "https://packagist.org/downloads/",
 880 |             "license": [
 881 |                 "BSD-3-Clause"
 882 |             ],
 883 |             "authors": [
 884 |                 {
 885 |                     "name": "Sebastian Bergmann",
 886 |                     "email": "sebastian@phpunit.de"
 887 |                 }
 888 |             ],
 889 |             "description": "Wrapper around PHP's tokenizer extension.",
 890 |             "homepage": "https://github.com/sebastianbergmann/php-token-stream/",
 891 |             "keywords": [
 892 |                 "tokenizer"
 893 |             ],
 894 |             "time": "2015-09-15 10:49:45"
 895 |         },
 896 |         {
 897 |             "name": "phpunit/phpunit",
 898 |             "version": "4.8.21",
 899 |             "source": {
 900 |                 "type": "git",
 901 |                 "url": "https://github.com/sebastianbergmann/phpunit.git",
 902 |                 "reference": "ea76b17bced0500a28098626b84eda12dbcf119c"
 903 |             },
 904 |             "dist": {
 905 |                 "type": "zip",
 906 |                 "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/ea76b17bced0500a28098626b84eda12dbcf119c",
 907 |                 "reference": "ea76b17bced0500a28098626b84eda12dbcf119c",
 908 |                 "shasum": ""
 909 |             },
 910 |             "require": {
 911 |                 "ext-dom": "*",
 912 |                 "ext-json": "*",
 913 |                 "ext-pcre": "*",
 914 |                 "ext-reflection": "*",
 915 |                 "ext-spl": "*",
 916 |                 "php": ">=5.3.3",
 917 |                 "phpspec/prophecy": "^1.3.1",
 918 |                 "phpunit/php-code-coverage": "~2.1",
 919 |                 "phpunit/php-file-iterator": "~1.4",
 920 |                 "phpunit/php-text-template": "~1.2",
 921 |                 "phpunit/php-timer": ">=1.0.6",
 922 |                 "phpunit/phpunit-mock-objects": "~2.3",
 923 |                 "sebastian/comparator": "~1.1",
 924 |                 "sebastian/diff": "~1.2",
 925 |                 "sebastian/environment": "~1.3",
 926 |                 "sebastian/exporter": "~1.2",
 927 |                 "sebastian/global-state": "~1.0",
 928 |                 "sebastian/version": "~1.0",
 929 |                 "symfony/yaml": "~2.1|~3.0"
 930 |             },
 931 |             "suggest": {
 932 |                 "phpunit/php-invoker": "~1.1"
 933 |             },
 934 |             "bin": [
 935 |                 "phpunit"
 936 |             ],
 937 |             "type": "library",
 938 |             "extra": {
 939 |                 "branch-alias": {
 940 |                     "dev-master": "4.8.x-dev"
 941 |                 }
 942 |             },
 943 |             "autoload": {
 944 |                 "classmap": [
 945 |                     "src/"
 946 |                 ]
 947 |             },
 948 |             "notification-url": "https://packagist.org/downloads/",
 949 |             "license": [
 950 |                 "BSD-3-Clause"
 951 |             ],
 952 |             "authors": [
 953 |                 {
 954 |                     "name": "Sebastian Bergmann",
 955 |                     "email": "sebastian@phpunit.de",
 956 |                     "role": "lead"
 957 |                 }
 958 |             ],
 959 |             "description": "The PHP Unit Testing framework.",
 960 |             "homepage": "https://phpunit.de/",
 961 |             "keywords": [
 962 |                 "phpunit",
 963 |                 "testing",
 964 |                 "xunit"
 965 |             ],
 966 |             "time": "2015-12-12 07:45:58"
 967 |         },
 968 |         {
 969 |             "name": "phpunit/phpunit-mock-objects",
 970 |             "version": "2.3.8",
 971 |             "source": {
 972 |                 "type": "git",
 973 |                 "url": "https://github.com/sebastianbergmann/phpunit-mock-objects.git",
 974 |                 "reference": "ac8e7a3db35738d56ee9a76e78a4e03d97628983"
 975 |             },
 976 |             "dist": {
 977 |                 "type": "zip",
 978 |                 "url": "https://api.github.com/repos/sebastianbergmann/phpunit-mock-objects/zipball/ac8e7a3db35738d56ee9a76e78a4e03d97628983",
 979 |                 "reference": "ac8e7a3db35738d56ee9a76e78a4e03d97628983",
 980 |                 "shasum": ""
 981 |             },
 982 |             "require": {
 983 |                 "doctrine/instantiator": "^1.0.2",
 984 |                 "php": ">=5.3.3",
 985 |                 "phpunit/php-text-template": "~1.2",
 986 |                 "sebastian/exporter": "~1.2"
 987 |             },
 988 |             "require-dev": {
 989 |                 "phpunit/phpunit": "~4.4"
 990 |             },
 991 |             "suggest": {
 992 |                 "ext-soap": "*"
 993 |             },
 994 |             "type": "library",
 995 |             "extra": {
 996 |                 "branch-alias": {
 997 |                     "dev-master": "2.3.x-dev"
 998 |                 }
 999 |             },
1000 |             "autoload": {
1001 |                 "classmap": [
1002 |                     "src/"
1003 |                 ]
1004 |             },
1005 |             "notification-url": "https://packagist.org/downloads/",
1006 |             "license": [
1007 |                 "BSD-3-Clause"
1008 |             ],
1009 |             "authors": [
1010 |                 {
1011 |                     "name": "Sebastian Bergmann",
1012 |                     "email": "sb@sebastian-bergmann.de",
1013 |                     "role": "lead"
1014 |                 }
1015 |             ],
1016 |             "description": "Mock Object library for PHPUnit",
1017 |             "homepage": "https://github.com/sebastianbergmann/phpunit-mock-objects/",
1018 |             "keywords": [
1019 |                 "mock",
1020 |                 "xunit"
1021 |             ],
1022 |             "time": "2015-10-02 06:51:40"
1023 |         },
1024 |         {
1025 |             "name": "psr/log",
1026 |             "version": "1.0.0",
1027 |             "source": {
1028 |                 "type": "git",
1029 |                 "url": "https://github.com/php-fig/log.git",
1030 |                 "reference": "fe0936ee26643249e916849d48e3a51d5f5e278b"
1031 |             },
1032 |             "dist": {
1033 |                 "type": "zip",
1034 |                 "url": "https://api.github.com/repos/php-fig/log/zipball/fe0936ee26643249e916849d48e3a51d5f5e278b",
1035 |                 "reference": "fe0936ee26643249e916849d48e3a51d5f5e278b",
1036 |                 "shasum": ""
1037 |             },
1038 |             "type": "library",
1039 |             "autoload": {
1040 |                 "psr-0": {
1041 |                     "Psr\\Log\\": ""
1042 |                 }
1043 |             },
1044 |             "notification-url": "https://packagist.org/downloads/",
1045 |             "license": [
1046 |                 "MIT"
1047 |             ],
1048 |             "authors": [
1049 |                 {
1050 |                     "name": "PHP-FIG",
1051 |                     "homepage": "http://www.php-fig.org/"
1052 |                 }
1053 |             ],
1054 |             "description": "Common interface for logging libraries",
1055 |             "keywords": [
1056 |                 "log",
1057 |                 "psr",
1058 |                 "psr-3"
1059 |             ],
1060 |             "time": "2012-12-21 11:40:51"
1061 |         },
1062 |         {
1063 |             "name": "satooshi/php-coveralls",
1064 |             "version": "v0.6.1",
1065 |             "source": {
1066 |                 "type": "git",
1067 |                 "url": "https://github.com/satooshi/php-coveralls.git",
1068 |                 "reference": "dd0df95bd37a7cf5c5c50304dfe260ffe4b50760"
1069 |             },
1070 |             "dist": {
1071 |                 "type": "zip",
1072 |                 "url": "https://api.github.com/repos/satooshi/php-coveralls/zipball/dd0df95bd37a7cf5c5c50304dfe260ffe4b50760",
1073 |                 "reference": "dd0df95bd37a7cf5c5c50304dfe260ffe4b50760",
1074 |                 "shasum": ""
1075 |             },
1076 |             "require": {
1077 |                 "ext-curl": "*",
1078 |                 "ext-json": "*",
1079 |                 "ext-simplexml": "*",
1080 |                 "guzzle/guzzle": ">=3.0",
1081 |                 "php": ">=5.3",
1082 |                 "psr/log": "1.0.0",
1083 |                 "symfony/config": ">=2.0",
1084 |                 "symfony/console": ">=2.0",
1085 |                 "symfony/stopwatch": ">=2.2",
1086 |                 "symfony/yaml": ">=2.0"
1087 |             },
1088 |             "require-dev": {
1089 |                 "apigen/apigen": "2.8.*@stable",
1090 |                 "pdepend/pdepend": "dev-master",
1091 |                 "phpmd/phpmd": "dev-master",
1092 |                 "phpunit/php-invoker": ">=1.1.0,<1.2.0",
1093 |                 "phpunit/phpunit": "3.7.*@stable",
1094 |                 "sebastian/finder-facade": "dev-master",
1095 |                 "sebastian/phpcpd": "1.4.*@stable",
1096 |                 "squizlabs/php_codesniffer": "1.4.*@stable",
1097 |                 "theseer/fdomdocument": "dev-master"
1098 |             },
1099 |             "bin": [
1100 |                 "composer/bin/coveralls"
1101 |             ],
1102 |             "type": "library",
1103 |             "autoload": {
1104 |                 "psr-0": {
1105 |                     "Contrib\\Component": "src/",
1106 |                     "Contrib\\Bundle": "src/"
1107 |                 }
1108 |             },
1109 |             "notification-url": "https://packagist.org/downloads/",
1110 |             "license": [
1111 |                 "MIT"
1112 |             ],
1113 |             "authors": [
1114 |                 {
1115 |                     "name": "Kitamura Satoshi",
1116 |                     "email": "with.no.parachute@gmail.com",
1117 |                     "homepage": "https://www.facebook.com/satooshi.jp"
1118 |                 }
1119 |             ],
1120 |             "description": "PHP client library for Coveralls API",
1121 |             "homepage": "https://github.com/satooshi/php-coveralls",
1122 |             "keywords": [
1123 |                 "ci",
1124 |                 "coverage",
1125 |                 "github",
1126 |                 "test"
1127 |             ],
1128 |             "time": "2013-05-04 08:07:33"
1129 |         },
1130 |         {
1131 |             "name": "sebastian/comparator",
1132 |             "version": "1.2.0",
1133 |             "source": {
1134 |                 "type": "git",
1135 |                 "url": "https://github.com/sebastianbergmann/comparator.git",
1136 |                 "reference": "937efb279bd37a375bcadf584dec0726f84dbf22"
1137 |             },
1138 |             "dist": {
1139 |                 "type": "zip",
1140 |                 "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/937efb279bd37a375bcadf584dec0726f84dbf22",
1141 |                 "reference": "937efb279bd37a375bcadf584dec0726f84dbf22",
1142 |                 "shasum": ""
1143 |             },
1144 |             "require": {
1145 |                 "php": ">=5.3.3",
1146 |                 "sebastian/diff": "~1.2",
1147 |                 "sebastian/exporter": "~1.2"
1148 |             },
1149 |             "require-dev": {
1150 |                 "phpunit/phpunit": "~4.4"
1151 |             },
1152 |             "type": "library",
1153 |             "extra": {
1154 |                 "branch-alias": {
1155 |                     "dev-master": "1.2.x-dev"
1156 |                 }
1157 |             },
1158 |             "autoload": {
1159 |                 "classmap": [
1160 |                     "src/"
1161 |                 ]
1162 |             },
1163 |             "notification-url": "https://packagist.org/downloads/",
1164 |             "license": [
1165 |                 "BSD-3-Clause"
1166 |             ],
1167 |             "authors": [
1168 |                 {
1169 |                     "name": "Jeff Welch",
1170 |                     "email": "whatthejeff@gmail.com"
1171 |                 },
1172 |                 {
1173 |                     "name": "Volker Dusch",
1174 |                     "email": "github@wallbash.com"
1175 |                 },
1176 |                 {
1177 |                     "name": "Bernhard Schussek",
1178 |                     "email": "bschussek@2bepublished.at"
1179 |                 },
1180 |                 {
1181 |                     "name": "Sebastian Bergmann",
1182 |                     "email": "sebastian@phpunit.de"
1183 |                 }
1184 |             ],
1185 |             "description": "Provides the functionality to compare PHP values for equality",
1186 |             "homepage": "http://www.github.com/sebastianbergmann/comparator",
1187 |             "keywords": [
1188 |                 "comparator",
1189 |                 "compare",
1190 |                 "equality"
1191 |             ],
1192 |             "time": "2015-07-26 15:48:44"
1193 |         },
1194 |         {
1195 |             "name": "sebastian/diff",
1196 |             "version": "1.4.1",
1197 |             "source": {
1198 |                 "type": "git",
1199 |                 "url": "https://github.com/sebastianbergmann/diff.git",
1200 |                 "reference": "13edfd8706462032c2f52b4b862974dd46b71c9e"
1201 |             },
1202 |             "dist": {
1203 |                 "type": "zip",
1204 |                 "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/13edfd8706462032c2f52b4b862974dd46b71c9e",
1205 |                 "reference": "13edfd8706462032c2f52b4b862974dd46b71c9e",
1206 |                 "shasum": ""
1207 |             },
1208 |             "require": {
1209 |                 "php": ">=5.3.3"
1210 |             },
1211 |             "require-dev": {
1212 |                 "phpunit/phpunit": "~4.8"
1213 |             },
1214 |             "type": "library",
1215 |             "extra": {
1216 |                 "branch-alias": {
1217 |                     "dev-master": "1.4-dev"
1218 |                 }
1219 |             },
1220 |             "autoload": {
1221 |                 "classmap": [
1222 |                     "src/"
1223 |                 ]
1224 |             },
1225 |             "notification-url": "https://packagist.org/downloads/",
1226 |             "license": [
1227 |                 "BSD-3-Clause"
1228 |             ],
1229 |             "authors": [
1230 |                 {
1231 |                     "name": "Kore Nordmann",
1232 |                     "email": "mail@kore-nordmann.de"
1233 |                 },
1234 |                 {
1235 |                     "name": "Sebastian Bergmann",
1236 |                     "email": "sebastian@phpunit.de"
1237 |                 }
1238 |             ],
1239 |             "description": "Diff implementation",
1240 |             "homepage": "https://github.com/sebastianbergmann/diff",
1241 |             "keywords": [
1242 |                 "diff"
1243 |             ],
1244 |             "time": "2015-12-08 07:14:41"
1245 |         },
1246 |         {
1247 |             "name": "sebastian/environment",
1248 |             "version": "1.3.3",
1249 |             "source": {
1250 |                 "type": "git",
1251 |                 "url": "https://github.com/sebastianbergmann/environment.git",
1252 |                 "reference": "6e7133793a8e5a5714a551a8324337374be209df"
1253 |             },
1254 |             "dist": {
1255 |                 "type": "zip",
1256 |                 "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/6e7133793a8e5a5714a551a8324337374be209df",
1257 |                 "reference": "6e7133793a8e5a5714a551a8324337374be209df",
1258 |                 "shasum": ""
1259 |             },
1260 |             "require": {
1261 |                 "php": ">=5.3.3"
1262 |             },
1263 |             "require-dev": {
1264 |                 "phpunit/phpunit": "~4.4"
1265 |             },
1266 |             "type": "library",
1267 |             "extra": {
1268 |                 "branch-alias": {
1269 |                     "dev-master": "1.3.x-dev"
1270 |                 }
1271 |             },
1272 |             "autoload": {
1273 |                 "classmap": [
1274 |                     "src/"
1275 |                 ]
1276 |             },
1277 |             "notification-url": "https://packagist.org/downloads/",
1278 |             "license": [
1279 |                 "BSD-3-Clause"
1280 |             ],
1281 |             "authors": [
1282 |                 {
1283 |                     "name": "Sebastian Bergmann",
1284 |                     "email": "sebastian@phpunit.de"
1285 |                 }
1286 |             ],
1287 |             "description": "Provides functionality to handle HHVM/PHP environments",
1288 |             "homepage": "http://www.github.com/sebastianbergmann/environment",
1289 |             "keywords": [
1290 |                 "Xdebug",
1291 |                 "environment",
1292 |                 "hhvm"
1293 |             ],
1294 |             "time": "2015-12-02 08:37:27"
1295 |         },
1296 |         {
1297 |             "name": "sebastian/exporter",
1298 |             "version": "1.2.1",
1299 |             "source": {
1300 |                 "type": "git",
1301 |                 "url": "https://github.com/sebastianbergmann/exporter.git",
1302 |                 "reference": "7ae5513327cb536431847bcc0c10edba2701064e"
1303 |             },
1304 |             "dist": {
1305 |                 "type": "zip",
1306 |                 "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/7ae5513327cb536431847bcc0c10edba2701064e",
1307 |                 "reference": "7ae5513327cb536431847bcc0c10edba2701064e",
1308 |                 "shasum": ""
1309 |             },
1310 |             "require": {
1311 |                 "php": ">=5.3.3",
1312 |                 "sebastian/recursion-context": "~1.0"
1313 |             },
1314 |             "require-dev": {
1315 |                 "phpunit/phpunit": "~4.4"
1316 |             },
1317 |             "type": "library",
1318 |             "extra": {
1319 |                 "branch-alias": {
1320 |                     "dev-master": "1.2.x-dev"
1321 |                 }
1322 |             },
1323 |             "autoload": {
1324 |                 "classmap": [
1325 |                     "src/"
1326 |                 ]
1327 |             },
1328 |             "notification-url": "https://packagist.org/downloads/",
1329 |             "license": [
1330 |                 "BSD-3-Clause"
1331 |             ],
1332 |             "authors": [
1333 |                 {
1334 |                     "name": "Jeff Welch",
1335 |                     "email": "whatthejeff@gmail.com"
1336 |                 },
1337 |                 {
1338 |                     "name": "Volker Dusch",
1339 |                     "email": "github@wallbash.com"
1340 |                 },
1341 |                 {
1342 |                     "name": "Bernhard Schussek",
1343 |                     "email": "bschussek@2bepublished.at"
1344 |                 },
1345 |                 {
1346 |                     "name": "Sebastian Bergmann",
1347 |                     "email": "sebastian@phpunit.de"
1348 |                 },
1349 |                 {
1350 |                     "name": "Adam Harvey",
1351 |                     "email": "aharvey@php.net"
1352 |                 }
1353 |             ],
1354 |             "description": "Provides the functionality to export PHP variables for visualization",
1355 |             "homepage": "http://www.github.com/sebastianbergmann/exporter",
1356 |             "keywords": [
1357 |                 "export",
1358 |                 "exporter"
1359 |             ],
1360 |             "time": "2015-06-21 07:55:53"
1361 |         },
1362 |         {
1363 |             "name": "sebastian/global-state",
1364 |             "version": "1.1.1",
1365 |             "source": {
1366 |                 "type": "git",
1367 |                 "url": "https://github.com/sebastianbergmann/global-state.git",
1368 |                 "reference": "bc37d50fea7d017d3d340f230811c9f1d7280af4"
1369 |             },
1370 |             "dist": {
1371 |                 "type": "zip",
1372 |                 "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/bc37d50fea7d017d3d340f230811c9f1d7280af4",
1373 |                 "reference": "bc37d50fea7d017d3d340f230811c9f1d7280af4",
1374 |                 "shasum": ""
1375 |             },
1376 |             "require": {
1377 |                 "php": ">=5.3.3"
1378 |             },
1379 |             "require-dev": {
1380 |                 "phpunit/phpunit": "~4.2"
1381 |             },
1382 |             "suggest": {
1383 |                 "ext-uopz": "*"
1384 |             },
1385 |             "type": "library",
1386 |             "extra": {
1387 |                 "branch-alias": {
1388 |                     "dev-master": "1.0-dev"
1389 |                 }
1390 |             },
1391 |             "autoload": {
1392 |                 "classmap": [
1393 |                     "src/"
1394 |                 ]
1395 |             },
1396 |             "notification-url": "https://packagist.org/downloads/",
1397 |             "license": [
1398 |                 "BSD-3-Clause"
1399 |             ],
1400 |             "authors": [
1401 |                 {
1402 |                     "name": "Sebastian Bergmann",
1403 |                     "email": "sebastian@phpunit.de"
1404 |                 }
1405 |             ],
1406 |             "description": "Snapshotting of global state",
1407 |             "homepage": "http://www.github.com/sebastianbergmann/global-state",
1408 |             "keywords": [
1409 |                 "global state"
1410 |             ],
1411 |             "time": "2015-10-12 03:26:01"
1412 |         },
1413 |         {
1414 |             "name": "sebastian/recursion-context",
1415 |             "version": "1.0.2",
1416 |             "source": {
1417 |                 "type": "git",
1418 |                 "url": "https://github.com/sebastianbergmann/recursion-context.git",
1419 |                 "reference": "913401df809e99e4f47b27cdd781f4a258d58791"
1420 |             },
1421 |             "dist": {
1422 |                 "type": "zip",
1423 |                 "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/913401df809e99e4f47b27cdd781f4a258d58791",
1424 |                 "reference": "913401df809e99e4f47b27cdd781f4a258d58791",
1425 |                 "shasum": ""
1426 |             },
1427 |             "require": {
1428 |                 "php": ">=5.3.3"
1429 |             },
1430 |             "require-dev": {
1431 |                 "phpunit/phpunit": "~4.4"
1432 |             },
1433 |             "type": "library",
1434 |             "extra": {
1435 |                 "branch-alias": {
1436 |                     "dev-master": "1.0.x-dev"
1437 |                 }
1438 |             },
1439 |             "autoload": {
1440 |                 "classmap": [
1441 |                     "src/"
1442 |                 ]
1443 |             },
1444 |             "notification-url": "https://packagist.org/downloads/",
1445 |             "license": [
1446 |                 "BSD-3-Clause"
1447 |             ],
1448 |             "authors": [
1449 |                 {
1450 |                     "name": "Jeff Welch",
1451 |                     "email": "whatthejeff@gmail.com"
1452 |                 },
1453 |                 {
1454 |                     "name": "Sebastian Bergmann",
1455 |                     "email": "sebastian@phpunit.de"
1456 |                 },
1457 |                 {
1458 |                     "name": "Adam Harvey",
1459 |                     "email": "aharvey@php.net"
1460 |                 }
1461 |             ],
1462 |             "description": "Provides functionality to recursively process PHP variables",
1463 |             "homepage": "http://www.github.com/sebastianbergmann/recursion-context",
1464 |             "time": "2015-11-11 19:50:13"
1465 |         },
1466 |         {
1467 |             "name": "sebastian/version",
1468 |             "version": "1.0.6",
1469 |             "source": {
1470 |                 "type": "git",
1471 |                 "url": "https://github.com/sebastianbergmann/version.git",
1472 |                 "reference": "58b3a85e7999757d6ad81c787a1fbf5ff6c628c6"
1473 |             },
1474 |             "dist": {
1475 |                 "type": "zip",
1476 |                 "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/58b3a85e7999757d6ad81c787a1fbf5ff6c628c6",
1477 |                 "reference": "58b3a85e7999757d6ad81c787a1fbf5ff6c628c6",
1478 |                 "shasum": ""
1479 |             },
1480 |             "type": "library",
1481 |             "autoload": {
1482 |                 "classmap": [
1483 |                     "src/"
1484 |                 ]
1485 |             },
1486 |             "notification-url": "https://packagist.org/downloads/",
1487 |             "license": [
1488 |                 "BSD-3-Clause"
1489 |             ],
1490 |             "authors": [
1491 |                 {
1492 |                     "name": "Sebastian Bergmann",
1493 |                     "email": "sebastian@phpunit.de",
1494 |                     "role": "lead"
1495 |                 }
1496 |             ],
1497 |             "description": "Library that helps with managing the version number of Git-hosted PHP projects",
1498 |             "homepage": "https://github.com/sebastianbergmann/version",
1499 |             "time": "2015-06-21 13:59:46"
1500 |         },
1501 |         {
1502 |             "name": "symfony/config",
1503 |             "version": "v3.0.1",
1504 |             "source": {
1505 |                 "type": "git",
1506 |                 "url": "https://github.com/symfony/config.git",
1507 |                 "reference": "58680a6516a457a6c65044fe33586c4a81fdff01"
1508 |             },
1509 |             "dist": {
1510 |                 "type": "zip",
1511 |                 "url": "https://api.github.com/repos/symfony/config/zipball/7ba87ead973916a35487821851064ced061ec547",
1512 |                 "reference": "58680a6516a457a6c65044fe33586c4a81fdff01",
1513 |                 "shasum": ""
1514 |             },
1515 |             "require": {
1516 |                 "php": ">=5.5.9",
1517 |                 "symfony/filesystem": "~2.8|~3.0"
1518 |             },
1519 |             "type": "library",
1520 |             "extra": {
1521 |                 "branch-alias": {
1522 |                     "dev-master": "3.0-dev"
1523 |                 }
1524 |             },
1525 |             "autoload": {
1526 |                 "psr-4": {
1527 |                     "Symfony\\Component\\Config\\": ""
1528 |                 },
1529 |                 "exclude-from-classmap": [
1530 |                     "/Tests/"
1531 |                 ]
1532 |             },
1533 |             "notification-url": "https://packagist.org/downloads/",
1534 |             "license": [
1535 |                 "MIT"
1536 |             ],
1537 |             "authors": [
1538 |                 {
1539 |                     "name": "Fabien Potencier",
1540 |                     "email": "fabien@symfony.com"
1541 |                 },
1542 |                 {
1543 |                     "name": "Symfony Community",
1544 |                     "homepage": "https://symfony.com/contributors"
1545 |                 }
1546 |             ],
1547 |             "description": "Symfony Config Component",
1548 |             "homepage": "https://symfony.com",
1549 |             "time": "2015-12-26 13:39:53"
1550 |         },
1551 |         {
1552 |             "name": "symfony/event-dispatcher",
1553 |             "version": "v2.8.1",
1554 |             "source": {
1555 |                 "type": "git",
1556 |                 "url": "https://github.com/symfony/event-dispatcher.git",
1557 |                 "reference": "a5eb815363c0388e83247e7e9853e5dbc14999cc"
1558 |             },
1559 |             "dist": {
1560 |                 "type": "zip",
1561 |                 "url": "https://api.github.com/repos/symfony/event-dispatcher/zipball/a5eb815363c0388e83247e7e9853e5dbc14999cc",
1562 |                 "reference": "a5eb815363c0388e83247e7e9853e5dbc14999cc",
1563 |                 "shasum": ""
1564 |             },
1565 |             "require": {
1566 |                 "php": ">=5.3.9"
1567 |             },
1568 |             "require-dev": {
1569 |                 "psr/log": "~1.0",
1570 |                 "symfony/config": "~2.0,>=2.0.5|~3.0.0",
1571 |                 "symfony/dependency-injection": "~2.6|~3.0.0",
1572 |                 "symfony/expression-language": "~2.6|~3.0.0",
1573 |                 "symfony/stopwatch": "~2.3|~3.0.0"
1574 |             },
1575 |             "suggest": {
1576 |                 "symfony/dependency-injection": "",
1577 |                 "symfony/http-kernel": ""
1578 |             },
1579 |             "type": "library",
1580 |             "extra": {
1581 |                 "branch-alias": {
1582 |                     "dev-master": "2.8-dev"
1583 |                 }
1584 |             },
1585 |             "autoload": {
1586 |                 "psr-4": {
1587 |                     "Symfony\\Component\\EventDispatcher\\": ""
1588 |                 },
1589 |                 "exclude-from-classmap": [
1590 |                     "/Tests/"
1591 |                 ]
1592 |             },
1593 |             "notification-url": "https://packagist.org/downloads/",
1594 |             "license": [
1595 |                 "MIT"
1596 |             ],
1597 |             "authors": [
1598 |                 {
1599 |                     "name": "Fabien Potencier",
1600 |                     "email": "fabien@symfony.com"
1601 |                 },
1602 |                 {
1603 |                     "name": "Symfony Community",
1604 |                     "homepage": "https://symfony.com/contributors"
1605 |                 }
1606 |             ],
1607 |             "description": "Symfony EventDispatcher Component",
1608 |             "homepage": "https://symfony.com",
1609 |             "time": "2015-10-30 20:15:42"
1610 |         },
1611 |         {
1612 |             "name": "symfony/filesystem",
1613 |             "version": "v3.0.1",
1614 |             "source": {
1615 |                 "type": "git",
1616 |                 "url": "https://github.com/symfony/filesystem.git",
1617 |                 "reference": "c2e59d11dccd135dc8f00ee97f34fe1de842e70c"
1618 |             },
1619 |             "dist": {
1620 |                 "type": "zip",
1621 |                 "url": "https://api.github.com/repos/symfony/filesystem/zipball/c2e59d11dccd135dc8f00ee97f34fe1de842e70c",
1622 |                 "reference": "c2e59d11dccd135dc8f00ee97f34fe1de842e70c",
1623 |                 "shasum": ""
1624 |             },
1625 |             "require": {
1626 |                 "php": ">=5.5.9"
1627 |             },
1628 |             "type": "library",
1629 |             "extra": {
1630 |                 "branch-alias": {
1631 |                     "dev-master": "3.0-dev"
1632 |                 }
1633 |             },
1634 |             "autoload": {
1635 |                 "psr-4": {
1636 |                     "Symfony\\Component\\Filesystem\\": ""
1637 |                 },
1638 |                 "exclude-from-classmap": [
1639 |                     "/Tests/"
1640 |                 ]
1641 |             },
1642 |             "notification-url": "https://packagist.org/downloads/",
1643 |             "license": [
1644 |                 "MIT"
1645 |             ],
1646 |             "authors": [
1647 |                 {
1648 |                     "name": "Fabien Potencier",
1649 |                     "email": "fabien@symfony.com"
1650 |                 },
1651 |                 {
1652 |                     "name": "Symfony Community",
1653 |                     "homepage": "https://symfony.com/contributors"
1654 |                 }
1655 |             ],
1656 |             "description": "Symfony Filesystem Component",
1657 |             "homepage": "https://symfony.com",
1658 |             "time": "2015-12-22 10:39:06"
1659 |         },
1660 |         {
1661 |             "name": "symfony/stopwatch",
1662 |             "version": "v3.0.1",
1663 |             "source": {
1664 |                 "type": "git",
1665 |                 "url": "https://github.com/symfony/stopwatch.git",
1666 |                 "reference": "6aeac8907e3e1340a0033b0a9ec075f8e6524800"
1667 |             },
1668 |             "dist": {
1669 |                 "type": "zip",
1670 |                 "url": "https://api.github.com/repos/symfony/stopwatch/zipball/6aeac8907e3e1340a0033b0a9ec075f8e6524800",
1671 |                 "reference": "6aeac8907e3e1340a0033b0a9ec075f8e6524800",
1672 |                 "shasum": ""
1673 |             },
1674 |             "require": {
1675 |                 "php": ">=5.5.9"
1676 |             },
1677 |             "type": "library",
1678 |             "extra": {
1679 |                 "branch-alias": {
1680 |                     "dev-master": "3.0-dev"
1681 |                 }
1682 |             },
1683 |             "autoload": {
1684 |                 "psr-4": {
1685 |                     "Symfony\\Component\\Stopwatch\\": ""
1686 |                 },
1687 |                 "exclude-from-classmap": [
1688 |                     "/Tests/"
1689 |                 ]
1690 |             },
1691 |             "notification-url": "https://packagist.org/downloads/",
1692 |             "license": [
1693 |                 "MIT"
1694 |             ],
1695 |             "authors": [
1696 |                 {
1697 |                     "name": "Fabien Potencier",
1698 |                     "email": "fabien@symfony.com"
1699 |                 },
1700 |                 {
1701 |                     "name": "Symfony Community",
1702 |                     "homepage": "https://symfony.com/contributors"
1703 |                 }
1704 |             ],
1705 |             "description": "Symfony Stopwatch Component",
1706 |             "homepage": "https://symfony.com",
1707 |             "time": "2015-10-30 23:35:59"
1708 |         },
1709 |         {
1710 |             "name": "symfony/yaml",
1711 |             "version": "v3.0.1",
1712 |             "source": {
1713 |                 "type": "git",
1714 |                 "url": "https://github.com/symfony/yaml.git",
1715 |                 "reference": "3df409958a646dad2bc5046c3fb671ee24a1a691"
1716 |             },
1717 |             "dist": {
1718 |                 "type": "zip",
1719 |                 "url": "https://api.github.com/repos/symfony/yaml/zipball/3df409958a646dad2bc5046c3fb671ee24a1a691",
1720 |                 "reference": "3df409958a646dad2bc5046c3fb671ee24a1a691",
1721 |                 "shasum": ""
1722 |             },
1723 |             "require": {
1724 |                 "php": ">=5.5.9"
1725 |             },
1726 |             "type": "library",
1727 |             "extra": {
1728 |                 "branch-alias": {
1729 |                     "dev-master": "3.0-dev"
1730 |                 }
1731 |             },
1732 |             "autoload": {
1733 |                 "psr-4": {
1734 |                     "Symfony\\Component\\Yaml\\": ""
1735 |                 },
1736 |                 "exclude-from-classmap": [
1737 |                     "/Tests/"
1738 |                 ]
1739 |             },
1740 |             "notification-url": "https://packagist.org/downloads/",
1741 |             "license": [
1742 |                 "MIT"
1743 |             ],
1744 |             "authors": [
1745 |                 {
1746 |                     "name": "Fabien Potencier",
1747 |                     "email": "fabien@symfony.com"
1748 |                 },
1749 |                 {
1750 |                     "name": "Symfony Community",
1751 |                     "homepage": "https://symfony.com/contributors"
1752 |                 }
1753 |             ],
1754 |             "description": "Symfony Yaml Component",
1755 |             "homepage": "https://symfony.com",
1756 |             "time": "2015-12-26 13:39:53"
1757 |         }
1758 |     ],
1759 |     "aliases": [],
1760 |     "minimum-stability": "stable",
1761 |     "stability-flags": [],
1762 |     "prefer-stable": false,
1763 |     "prefer-lowest": false,
1764 |     "platform": {
1765 |         "php": ">=5.5.0"
1766 |     },
1767 |     "platform-dev": []
1768 | }
1769 | 


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