├── test
    ├── tmp
    │   └── .gitignore
    ├── ExecutorTest.php
    ├── PHPNotifyerTest.php
    ├── TaskTest.php
    ├── FileWriterTest.php
    └── FileReaderTest.php
├── .gitignore
├── .travis.yml
├── composer.json
├── src
    ├── interfaces
    │   ├── ReaderInterface.php
    │   ├── RWInterface.php
    │   ├── ExecutorInterface.php
    │   ├── WriterInterface.php
    │   └── TaskInterface.php
    ├── FileReader.php
    ├── RWFactory.php
    ├── Executor.php
    ├── PHPNotifier.php
    ├── Task.php
    └── FileWriter.php
├── bin
    └── phpnotifier
├── LICENSE
├── README.md
└── composer.lock


/test/tmp/.gitignore:
--------------------------------------------------------------------------------
1 | 


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


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: php
2 | php:
3 |   - '5.4'
4 |   - '5.5'
5 |   - '5.6'
6 |   - '7.0'
7 | install: composer install --no-dev
8 | script: phpunit test/


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "krydos/php-notifier",
 3 |   "description": "PHP task scheduler",
 4 |   "license": "MIT",
 5 |   "version": "0.3.0",
 6 |   "autoload": {
 7 |     "psr-4": {
 8 |       "PHPNotifier\\": "src"
 9 |     }
10 |   },
11 |   "require-dev": {
12 |     "phpunit/phpunit":"5.2.*"
13 |   },
14 |   "bin": [
15 |     "bin/phpnotifier"
16 |   ]
17 | }


--------------------------------------------------------------------------------
/test/ExecutorTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | require __DIR__ . "/../vendor/autoload.php";
 3 | /**
 4 |  * Created by IntelliJ IDEA.
 5 |  * User: KryDos
 6 |  * Date: 26/03/16
 7 |  * Time: 18:22
 8 |  */
 9 | class ExecutorTest extends PHPUnit_Framework_TestCase
10 | {
11 |     public function testCheckDefaultClass()
12 |     {
13 |         $this->assertTrue(class_exists('\PHPNotifier\Executor'));
14 |     }
15 | }


--------------------------------------------------------------------------------
/src/interfaces/ReaderInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by IntelliJ IDEA.
 4 |  * User: KryDos
 5 |  * Date: 22/03/16
 6 |  * Time: 23:33
 7 |  */
 8 | 
 9 | namespace PHPNotifier\interfaces;
10 | 
11 | 
12 | interface ReaderInterface
13 | {
14 |     /**
15 |      * returns list of tasks to execute
16 |      *
17 |      * @return TaskInterface[]
18 |      */
19 |     public function getTasksToExecute();
20 | }


--------------------------------------------------------------------------------
/bin/phpnotifier:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env php
 2 | <?php
 3 | require __DIR__ . "/../../../autoload.php";
 4 | 
 5 | $path_to_store = (isset($argv[1]) ? $argv[1] : null);
 6 | if (!$path_to_store) {
 7 |     echo "Path to store required\n";
 8 |     exit(1);
 9 | }
10 | 
11 | $executor = new \PHPNotifier\Executor(
12 |     new \PHPNotifier\FileReader($path_to_store),
13 |     new \PHPNotifier\FileWriter($path_to_store)
14 | );
15 | 
16 | $executor->run();


--------------------------------------------------------------------------------
/src/interfaces/RWInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by IntelliJ IDEA.
 4 |  * User: KryDos
 5 |  * Date: 23/03/16
 6 |  * Time: 00:24
 7 |  */
 8 | 
 9 | namespace PHPNotifier\interfaces;
10 | 
11 | 
12 | interface RWInterface
13 | {
14 |     /**
15 |      * returns writer
16 |      *
17 |      * @return WriterInterface
18 |      */
19 |     public function getWriter();
20 | 
21 |     /**
22 |      * returns reader
23 |      *
24 |      * @return ReaderInterface
25 |      */
26 |     public function getReader();
27 | }


--------------------------------------------------------------------------------
/src/interfaces/ExecutorInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by IntelliJ IDEA.
 4 |  * User: KryDos
 5 |  * Date: 26/03/16
 6 |  * Time: 18:27
 7 |  */
 8 | 
 9 | namespace PHPNotifier\interfaces;
10 | 
11 | 
12 | interface ExecutorInterface
13 | {
14 |     /**
15 |      * run loop
16 |      *
17 |      * @return bool
18 |      */
19 |     public function run();
20 | 
21 |     /**
22 |      * set reader for tasks
23 |      *
24 |      * @param ReaderInterface $reader
25 |      * @return mixed
26 |      */
27 |     public function setReader(ReaderInterface $reader);
28 | 
29 |     /**
30 |      * set tasks writer
31 |      *
32 |      * @param WriterInterface $writer
33 |      * @return mixed
34 |      */
35 |     public function setWriter(WriterInterface $writer);
36 | }


--------------------------------------------------------------------------------
/src/interfaces/WriterInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by IntelliJ IDEA.
 4 |  * User: KryDos
 5 |  * Date: 22/03/16
 6 |  * Time: 22:32
 7 |  */
 8 | 
 9 | namespace PHPNotifier\interfaces;
10 | 
11 | 
12 | interface WriterInterface
13 | {
14 |     /**
15 |      * Writes task to the store
16 |      *
17 |      * @param TaskInterface $task
18 |      * @return bool
19 |      */
20 |     public function write(TaskInterface $task);
21 | 
22 |     /**
23 |      * replaces task by ID
24 |      *
25 |      * @param $id
26 |      * @param TaskInterface $task
27 |      * @return bool
28 |      */
29 |     public function replace($id, TaskInterface $task);
30 | 
31 |     /**
32 |      * remove task from store
33 |      *
34 |      * @param $id
35 |      * @return mixed
36 |      */
37 |     public function removeTaskById($id);
38 | 
39 |     /**
40 |      * create file db or
41 |      * db in any other place
42 |      *
43 |      * @return mixed
44 |      */
45 |     public function createDb();
46 | }


--------------------------------------------------------------------------------
/src/interfaces/TaskInterface.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by IntelliJ IDEA.
 4 |  * User: KryDos
 5 |  * Date: 22/03/16
 6 |  * Time: 22:23
 7 |  */
 8 | 
 9 | namespace PHPNotifier\interfaces;
10 | 
11 | 
12 | interface TaskInterface
13 | {
14 |     /**
15 |      * returns unix timestamp
16 |      * of when command should be executed
17 |      *
18 |      * @return int
19 |      */
20 |     public function getTimeToExecute();
21 | 
22 |     /**
23 |      * returns command name
24 |      * to execute
25 |      *
26 |      * @return string
27 |      */
28 |     public function getCommand();
29 | 
30 |     /**
31 |      * returns array of parameters
32 |      *
33 |      * @return array
34 |      */
35 |     public function getParamsArray();
36 | 
37 |     /**
38 |      * returns string of parameters
39 |      *
40 |      * @return mixed
41 |      */
42 |     public function getParamsString();
43 | 
44 |     /**
45 |      * returns id of the task
46 |      *
47 |      * @return mixed
48 |      */
49 |     public function getId();
50 | 
51 |     /**
52 |      * executes command
53 |      *
54 |      * @return null
55 |      */
56 |     public function execute();
57 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2016 Ruslan Bekenev
 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 | 


--------------------------------------------------------------------------------
/src/FileReader.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by IntelliJ IDEA.
 4 |  * User: KryDos
 5 |  * Date: 22/03/16
 6 |  * Time: 23:35
 7 |  */
 8 | 
 9 | namespace PHPNotifier;
10 | 
11 | 
12 | use PHPNotifier\interfaces\ReaderInterface;
13 | use PHPNotifier\interfaces\TaskInterface;
14 | 
15 | class FileReader implements ReaderInterface
16 | {
17 |     protected $db_name;
18 | 
19 |     public function __construct($path_to_store)
20 |     {
21 |         if (!is_string($path_to_store)) {
22 |             throw new \InvalidArgumentException("Class accepts only string as store value");
23 |         }
24 |         $this->db_name = $path_to_store;
25 |     }
26 | 
27 |     /**
28 |      * returns list of tasks to execute
29 |      *
30 |      * @return TaskInterface[]
31 |      */
32 |     public function getTasksToExecute()
33 |     {
34 |         $current_time = time();
35 | 
36 |         if (!file_exists($this->db_name)) {
37 |             return [];
38 |         }
39 | 
40 |         $lines = file($this->db_name);
41 | 
42 |         $tasks = [];
43 |         foreach ($lines as $line) {
44 |             $task_json = json_decode($line);
45 |             if ($current_time == $task_json->execution_time) {
46 |                 $tasks[] = Task::fillTask($task_json);
47 |             }
48 |         }
49 | 
50 |         return $tasks;
51 |     }
52 | }


--------------------------------------------------------------------------------
/test/PHPNotifyerTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | require __DIR__ . "/../vendor/autoload.php";
 3 | /**
 4 |  * Created by IntelliJ IDEA.
 5 |  * User: KryDos
 6 |  * Date: 22/03/16
 7 |  * Time: 21:27
 8 |  */
 9 | class PHPNotifierTest extends PHPUnit_Framework_TestCase
10 | {
11 |     public function testClassExists()
12 |     {
13 |         $this->assertTrue(class_exists('\PHPNotifier\PHPNotifier'));
14 |     }
15 | 
16 |     /**
17 |      * @expectedException InvalidArgumentException
18 |      */
19 |     public function testExceptionWhenTryingToWriteIfWriterIsNotSet()
20 |     {
21 |         $notifier = new \PHPNotifier\PHPNotifier(\PHPNotifier\PHPNotifier::FILE_METHOD, 'test');
22 |         $notifier->scheduleTaskAtTime(1000, '');
23 |     }
24 | 
25 |     /**
26 |      * @expectedException InvalidArgumentException
27 |      */
28 |     public function testNotNumericTime()
29 |     {
30 |         $notifier = new \PHPNotifier\PHPNotifier(\PHPNotifier\PHPNotifier::FILE_METHOD, 'test');
31 |         $notifier->scheduleTaskAtTime('unknown string', '', ['hello', 'world']);
32 |     }
33 | 
34 |     public function testValidDateStringShouldBeAccepted()
35 |     {
36 |         $notifier = new \PHPNotifier\PHPNotifier(\PHPNotifier\PHPNotifier::FILE_METHOD, 'testdir');
37 |         $notifier->scheduleTaskAtTime('2016-04-04 00:00:00', '', []);
38 |     }
39 | }


--------------------------------------------------------------------------------
/test/TaskTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | require __DIR__ . "/../vendor/autoload.php";
 3 | /**
 4 |  * Created by IntelliJ IDEA.
 5 |  * User: KryDos
 6 |  * Date: 22/03/16
 7 |  * Time: 22:11
 8 |  */
 9 | class TaskTest extends PHPUnit_Framework_TestCase
10 | {
11 |     public function testClassExists()
12 |     {
13 |         $this->assertTrue(class_exists('\PHPNotifier\Task'));
14 |     }
15 | 
16 |     public function testGetCommand()
17 |     {
18 |         $task = new \PHPNotifier\Task(1000, 'echo', [
19 |             'Hello World',
20 |             '>',
21 |             'file'
22 |         ]);
23 | 
24 |         $this->assertEquals('echo', $task->getCommand());
25 |     }
26 | 
27 |     public function testGetParametersWithSpaces()
28 |     {
29 |         $task = new \PHPNotifier\Task(1000, 'echo', [
30 |             'Hello World',
31 |             '>',
32 |             'file'
33 |         ]);
34 | 
35 |         $params = $task->getParamsString();
36 |         $this->assertEquals(' Hello World > file', $params);
37 |     }
38 | 
39 |     public function testTaskExecuted()
40 |     {
41 |         $store_file = __DIR__ . '/tmp/test.file.created.by.test.task';
42 |         $task = new \PHPNotifier\Task(1000, 'echo', [
43 |             'Hello World',
44 |             '>',
45 |             $store_file
46 |         ]);
47 | 
48 |         $task->execute();
49 | 
50 |         $this->assertTrue(file_exists($store_file));
51 |         $test_file_content = file_get_contents($store_file);
52 |         $this->assertEquals("Hello World\n", $test_file_content);
53 | 
54 |         unlink($store_file);
55 |     }
56 | }


--------------------------------------------------------------------------------
/src/RWFactory.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by IntelliJ IDEA.
 4 |  * User: KryDos
 5 |  * Date: 23/03/16
 6 |  * Time: 00:28
 7 |  */
 8 | 
 9 | namespace PHPNotifier;
10 | 
11 | 
12 | use PHPNotifier\interfaces\ReaderInterface;
13 | use PHPNotifier\interfaces\RWInterface;
14 | use PHPNotifier\interfaces\WriterInterface;
15 | 
16 | class RWFactory implements RWInterface
17 | {
18 |     protected $reader;
19 |     protected $writer;
20 | 
21 |     /**
22 |      * RWFactory constructor.
23 |      *
24 |      * @param $method method of reader/writer
25 |      * @param $store path to file or db name
26 |      */
27 |     public function __construct($method, $store)
28 |     {
29 |         $reader_class = '\PHPNotifier\\' . $method.'Reader';
30 |         $writer_class = '\PHPNotifier\\' . $method.'Writer';
31 |         if (!class_exists($reader_class)) {
32 |             throw new \InvalidArgumentException('Class ' . $reader_class . ' does not exist');
33 |         }
34 | 
35 |         if (!class_exists($writer_class)) {
36 |             throw new \InvalidArgumentException('Class ' . $writer_class . ' does not exist');
37 |         }
38 | 
39 |         $this->reader = new $reader_class($store);
40 |         $this->writer = new $writer_class($store);
41 |     }
42 | 
43 |     /**
44 |      * returns writer
45 |      *
46 |      * @return WriterInterface
47 |      */
48 |     public function getWriter()
49 |     {
50 |         return $this->writer;
51 |     }
52 | 
53 |     /**
54 |      * returns reader
55 |      *
56 |      * @return ReaderInterface
57 |      */
58 |     public function getReader()
59 |     {
60 |         return $this->reader;
61 |     }
62 | }


--------------------------------------------------------------------------------
/test/FileWriterTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | require __DIR__ . "/../vendor/autoload.php";
 3 | 
 4 | /**
 5 |  * Created by IntelliJ IDEA.
 6 |  * User: KryDos
 7 |  * Date: 22/03/16
 8 |  * Time: 23:10
 9 |  */
10 | class FileWriterTest extends PHPUnit_Framework_TestCase
11 | {
12 |     public function testStoreShouldBeCreatedAfterWrite()
13 |     {
14 |         $store_file = __DIR__ . '/tmp/file_for_test';
15 |         $phpNotifier = new \PHPNotifier\PHPNotifier(\PHPNotifier\PHPNotifier::FILE_METHOD, $store_file);
16 | 
17 |         $phpNotifier->scheduleTaskAtTime(1000, '');
18 | 
19 |         $this->assertTrue(file_exists($store_file));
20 | 
21 |         unlink($store_file);
22 |     }
23 | 
24 |     public function testStoreFileShouldNotBeEmptyAfterInsert()
25 |     {
26 |         $store_file = __DIR__ . '/tmp/file_for_test';
27 |         $phpNotifier = new \PHPNotifier\PHPNotifier(\PHPNotifier\PHPNotifier::FILE_METHOD, $store_file);
28 | 
29 |         $phpNotifier->scheduleTaskAtTime(1000, '');
30 | 
31 |         $file_data = file($store_file);
32 | 
33 |         $this->assertFalse(empty($file_data));
34 | 
35 |         unlink($store_file);
36 |     }
37 | 
38 |     public function testRemoveTask()
39 |     {
40 |         $store_file = __DIR__ . '/tmp/file_for_test';
41 |         $notifier = new \PHPNotifier\PHPNotifier(\PHPNotifier\PHPNotifier::FILE_METHOD, $store_file);
42 | 
43 |         $current_time = time();
44 |         $notifier->scheduleTaskAtTime($current_time - 1, 'ls');
45 |         $notifier->scheduleTaskAtTime($current_time, 'ls');
46 |         $notifier->scheduleTaskAtTime($current_time + 1, 'ls');
47 | 
48 |         $this->assertEquals(3, count(file($store_file)));
49 | 
50 |         $tasks = $notifier->getReader()->getTasksToExecute();
51 | 
52 |         foreach ($tasks as $task) {
53 |             $notifier->getWriter()->removeTaskById($task->getId());
54 |         }
55 | 
56 |         $this->assertEquals(2, count(file($store_file)));
57 | 
58 |         unlink($store_file);
59 |     }
60 | }


--------------------------------------------------------------------------------
/test/FileReaderTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | use PHPNotifier\Task;
 3 | 
 4 | require __DIR__ . "/../vendor/autoload.php";
 5 | /**
 6 |  * Created by IntelliJ IDEA.
 7 |  * User: KryDos
 8 |  * Date: 23/03/16
 9 |  * Time: 00:47
10 |  */
11 | class FileReaderTest extends PHPUnit_Framework_TestCase
12 | {
13 |     public function testGetTasksToExecute()
14 |     {
15 |         $store_file = __DIR__ . '/tmp/file_for_test';
16 |         $notifier = new \PHPNotifier\PHPNotifier(\PHPNotifier\PHPNotifier::FILE_METHOD, $store_file);
17 | 
18 |         $current_time = time();
19 | 
20 |         /**
21 |          * I'm going to record 3 items
22 |          * since I'm not sure how fast tests are executing
23 |          * and this test is time sensitive
24 |          */
25 |         $notifier->scheduleTaskAtTime($current_time - 1, 'ls');
26 |         $notifier->scheduleTaskAtTime($current_time, 'ls');
27 |         $notifier->scheduleTaskAtTime($current_time + 1, 'ls');
28 | 
29 |         /** @var Task[] $tasks */
30 |         $tasks = $notifier->getReader()->getTasksToExecute();
31 |         $this->assertFalse(empty($tasks));
32 |         $this->containsOnlyInstancesOf(get_class($tasks[0]));
33 | 
34 |         unlink($store_file);
35 |     }
36 | 
37 |     public function testGetTasksToExecuteIfThereIsNoTasks()
38 |     {
39 |         $store_file = __DIR__ . '/tmp/file_for_test';
40 |         $notifier = new \PHPNotifier\PHPNotifier(\PHPNotifier\PHPNotifier::FILE_METHOD, $store_file);
41 | 
42 |         $current_time = time();
43 | 
44 |         /**
45 |          * I'm going to record 3 items
46 |          * all items are from passed
47 |          */
48 |         $notifier->scheduleTaskAtTime($current_time - 1, 'ls');
49 |         $notifier->scheduleTaskAtTime($current_time - 2, 'ls');
50 |         $notifier->scheduleTaskAtTime($current_time - 3, 'ls');
51 | 
52 |         /** @var Task[] $tasks */
53 |         $tasks = $notifier->getReader()->getTasksToExecute();
54 |         $this->assertTrue(empty($tasks));
55 | 
56 |         unlink($store_file);
57 |     }
58 | }


--------------------------------------------------------------------------------
/src/Executor.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by IntelliJ IDEA.
 4 |  * User: KryDos
 5 |  * Date: 26/03/16
 6 |  * Time: 18:29
 7 |  */
 8 | 
 9 | namespace PHPNotifier;
10 | 
11 | 
12 | use PHPNotifier\interfaces\ExecutorInterface;
13 | use PHPNotifier\interfaces\ReaderInterface;
14 | use PHPNotifier\interfaces\WriterInterface;
15 | 
16 | class Executor implements ExecutorInterface
17 | {
18 |     /** @var ReaderInterface $reader */
19 |     protected $reader;
20 | 
21 |     /** @var WriterInterface $writer */
22 |     protected $writer;
23 | 
24 |     public function __construct(ReaderInterface $reader, WriterInterface $writer)
25 |     {
26 |         $this->reader = $reader;
27 |         $this->writer = $writer;
28 |     }
29 | 
30 |     /**
31 |      * run loop
32 |      *
33 |      * @return bool
34 |      */
35 |     public function run()
36 |     {
37 |         while (true) {
38 |             $tasks = $this->reader->getTasksToExecute();
39 |             if (!empty($tasks)) {
40 |                 echo "Found " . count($tasks) . " to execute\n";
41 |                 foreach ($tasks as $task) {
42 |                     echo "going to execute task - " . $task->getId() . ' ' . $task->getCommand() . ' ' . $task->getParamsString() . "\n";
43 |                     $task->execute();
44 |                     echo "executed\n";
45 |                     echo "removing task...\t";
46 |                     $this->writer->removeTaskById($task->getId());
47 |                     echo "done...\n";
48 |                 }
49 |             }
50 | 
51 |             sleep(1);
52 |         }
53 |     }
54 | 
55 |     /**
56 |      * set reader for tasks
57 |      *
58 |      * @param ReaderInterface $reader
59 |      * @return mixed
60 |      */
61 |     public function setReader(ReaderInterface $reader)
62 |     {
63 |         $this->reader = $reader;
64 |     }
65 | 
66 |     /**
67 |      * set tasks writer
68 |      *
69 |      * @param WriterInterface $writer
70 |      * @return mixed
71 |      */
72 |     public function setWriter(WriterInterface $writer)
73 |     {
74 |         $this->writer = $writer;
75 |     }
76 | }


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | [![Build Status](https://travis-ci.org/KryDos/PHPNotifier.svg?branch=master)](https://travis-ci.org/KryDos/PHPNotifier)
 2 | 
 3 | PHPNotifier
 4 | ===========
 5 | 
 6 | **PHPNotifier** - is a task scheduler. Allows you to schedule a task that will be executed at any time you wish. 
 7 | 
 8 | Installation
 9 | ------------
10 | add to your composer.json - `"krydos/php-notifier": "*"`
11 |  
12 | Usage
13 | -----
14 | First of all you have to run a script that will be listening for new tasks and execute them when time came.
15 | 
16 | `php ./vendor/bin/phpnotifier /absolute/path/to/db.file`
17 | 
18 | or if you want to leave it working in background
19 | 
20 | `nohup php ./vendor/bin/phpnotifier /absolute/path/to/db.file & >/dev/null 2>&1 &`
21 | 
22 | Using `nohup` you can see log output in `nohup.out` file. 
23 | 
24 | How to create new tasks:
25 | 
26 | ```php
27 | use \PHPNotifier\PHPNotifier;
28 | 
29 | $scheduler = new PHPNotifier(PHPNotifier::FILE_METHOD, '/absolute/path/to/db.file');
30 | $scheduler->scheduleTaskIn(10, 'echo', [
31 |     'Hello world!'
32 |     '>'
33 |     'any_file'
34 | ]);  
35 | ```
36 | 
37 | This task will be executed in 10 seconds. Command that will be executed is `echo Hello world! > any_file`
38 | 
39 | Since sometimes you know exact time when you want to run a task and you don't want to calculate how many time is remaining
40 | there is another method exists - `scheduleTaskAtTime` with same signature.
41 | 
42 | ```php
43 | use \PHPNotifier\PHPNotifier;
44 | 
45 | $scheduler = new PHPNotifier(PHPNotifier::FILE_METHOD, '/absolute/path/to/db.file');
46 | $scheduler->scheduleTaskAtTime(1459382400, 'echo', [
47 |     'Hello world!'
48 |     '>'
49 |     'any_file'
50 | ]);  
51 | ```
52 | 
53 | This method accepts unix timestamp or \DateTime object as first argument. If you use `DateTime` PHP's object you can get this value by `getTimestamp()` method.
54 | 
55 | **make sure that binary you're trying to execute is exists in your system**
56 |  
57 | TODO
58 | ------
59 |  
60 | * support Redis as task store method
61 | * support as many store methods as possible
62 | * ~~ability to accept DateTime as first argument for `scheduleTaskAtTime` method~~
63 | * ~~ability to accept any valid date string as first argument of `scheduleTaskAtTime` method~~
64 | * ability to schedule repeatable tasks
65 |  
66 |  
67 | Contributing
68 | ------------
69 | There are no special rules. Just send a pull request or create an issue. 
70 |  
71 |  


--------------------------------------------------------------------------------
/src/PHPNotifier.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Created by IntelliJ IDEA.
 4 |  * User: KryDos
 5 |  * Date: 22/03/16
 6 |  * Time: 21:31
 7 |  */
 8 | 
 9 | namespace PHPNotifier;
10 | 
11 | 
12 | use PHPNotifier\interfaces\RWInterface;
13 | 
14 | class PHPNotifier
15 | {
16 |     /**
17 |      * This constant has partial name of
18 |      * Reader/Writer class, that will be
19 |      * used in the library
20 |      */
21 |     const FILE_METHOD = 'File';
22 | 
23 |     /** @var  RWInterface $rw*/
24 |     protected $rw;
25 | 
26 |     public function __construct($method, $store)
27 |     {
28 |         $this->rw = new RWFactory($method, $store);
29 |     }
30 | 
31 |     /**
32 |      * puts task inside a store
33 |      *
34 |      * @param Task $task
35 |      */
36 |     protected function schedule(Task $task)
37 |     {
38 |         $this->rw->getWriter()->createDb();
39 |         $this->rw->getWriter()->write($task);
40 |     }
41 | 
42 |     /**
43 |      * set exact time when command have to be executed
44 |      *
45 |      * @param mixed $when
46 |      * @param string $command
47 |      * @param array $params
48 |      */
49 |     public function scheduleTaskAtTime($when, $command, array $params = [])
50 |     {
51 |         if ($when instanceof \DateTime) {
52 |             $task = new Task($when->getTimestamp(), $command, $params);
53 |         } elseif (is_numeric($when)) {
54 |             $task = new Task($when, $command, $params);
55 |         } elseif(is_string($when) && ($timestamp = strtotime($when))) {
56 |             $task = new Task($timestamp, $command, $params);
57 |         } else {
58 |             throw new \InvalidArgumentException('time argument is not supported. Only integer, DateTime or valid date string are allowed');
59 |         }
60 | 
61 |         $this->schedule($task);
62 |     }
63 | 
64 |     /**
65 |      * execute task after $run_after seconds
66 |      *
67 |      * @param integer $run_after
68 |      * @param string $command
69 |      * @param array $params
70 |      */
71 |     public function scheduleTaskIn($run_after, $command, array $params = [])
72 |     {
73 |         $task = new Task((time() + $run_after), $command, $params);
74 |         $this->schedule($task);
75 |     }
76 | 
77 |     /**
78 |      * @return interfaces\ReaderInterface
79 |      */
80 |     public function getReader()
81 |     {
82 |         return $this->rw->getReader();
83 |     }
84 | 
85 |     /**
86 |      * @return interfaces\WriterInterface
87 |      */
88 |     public function getWriter()
89 |     {
90 |         return $this->rw->getWriter();
91 |     }
92 | }


--------------------------------------------------------------------------------
/src/Task.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Created by IntelliJ IDEA.
  4 |  * User: KryDos
  5 |  * Date: 22/03/16
  6 |  * Time: 22:10
  7 |  */
  8 | 
  9 | namespace PHPNotifier;
 10 | 
 11 | 
 12 | use PHPNotifier\interfaces\TaskInterface;
 13 | 
 14 | class Task implements TaskInterface
 15 | {
 16 |     protected $id;
 17 |     protected $timestamp;
 18 |     protected $command;
 19 |     protected $params;
 20 | 
 21 |     public function __construct($timestamp, $command, $params, $new = true)
 22 |     {
 23 |         $this->id = ($new ? uniqid() : null);
 24 |         $this->timestamp = $timestamp;
 25 |         $this->command = $command;
 26 |         $this->params = $params;
 27 |     }
 28 | 
 29 |     /**
 30 |      * @param $object
 31 |      * @return Task
 32 |      */
 33 |     public static function fillTask($object)
 34 |     {
 35 |         $task = new self($object->execution_time, $object->command, $object->params, false);
 36 |         $task->id = $object->id;
 37 | 
 38 |         return $task;
 39 |     }
 40 | 
 41 |     /**
 42 |      * returns unix timestamp
 43 |      * of when command should be executed
 44 |      *
 45 |      * @return int
 46 |      */
 47 |     public function getTimeToExecute()
 48 |     {
 49 |         return $this->timestamp;
 50 |     }
 51 | 
 52 |     /**
 53 |      * returns command name
 54 |      * to execute
 55 |      *
 56 |      * @return string
 57 |      */
 58 |     public function getCommand()
 59 |     {
 60 |         return $this->command;
 61 |     }
 62 | 
 63 |     /**
 64 |      * returns array of parameters
 65 |      *
 66 |      * @return array
 67 |      */
 68 |     public function getParamsArray()
 69 |     {
 70 |         $this->params;
 71 |     }
 72 | 
 73 |     /**
 74 |      * returns string of parameters
 75 |      *
 76 |      * @return mixed
 77 |      */
 78 |     public function getParamsString()
 79 |     {
 80 |         $params_string = '';
 81 | 
 82 |         if (is_array($this->params)) {
 83 |             foreach ($this->params as $item) {
 84 |                 $params_string .= ' ' . $item;
 85 |             }
 86 |         }
 87 | 
 88 |         if (is_string($this->params)) {
 89 |             return $this->params;
 90 |         }
 91 | 
 92 |         return $params_string;
 93 |     }
 94 | 
 95 |     /**
 96 |      * returns id of the task
 97 |      *
 98 |      * @return mixed
 99 |      */
100 |     public function getId()
101 |     {
102 |         return $this->id;
103 |     }
104 | 
105 |     /**
106 |      * executes command
107 |      *
108 |      * @return null
109 |      */
110 |     public function execute()
111 |     {
112 |         exec($this->getCommand() . $this->getParamsString());
113 |     }
114 | }


--------------------------------------------------------------------------------
/src/FileWriter.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Created by IntelliJ IDEA.
  4 |  * User: KryDos
  5 |  * Date: 22/03/16
  6 |  * Time: 22:19
  7 |  */
  8 | 
  9 | namespace PHPNotifier;
 10 | 
 11 | 
 12 | use PHPNotifier\interfaces\TaskInterface;
 13 | use PHPNotifier\interfaces\WriterInterface;
 14 | 
 15 | class FileWriter implements WriterInterface
 16 | {
 17 |     protected $db_name;
 18 | 
 19 |     public function __construct($path_to_store)
 20 |     {
 21 |         if (!is_string($path_to_store)) {
 22 |             throw new \InvalidArgumentException("Class accepts only string as store value");
 23 |         }
 24 | 
 25 |         $this->db_name = $path_to_store;
 26 |     }
 27 | 
 28 |     /**
 29 |      * Writes task to the store
 30 |      *
 31 |      * @param TaskInterface $task
 32 |      * @return bool
 33 |      */
 34 |     public function write(TaskInterface $task)
 35 |     {
 36 |         $json_record = json_encode([
 37 |             'id' => $task->getId(),
 38 |             'execution_time' => $task->getTimeToExecute(),
 39 |             'command' => $task->getCommand(),
 40 |             'params' => $task->getParamsString()
 41 |         ]);
 42 | 
 43 |         return (bool)file_put_contents($this->db_name, $json_record . "\n", FILE_APPEND);
 44 |     }
 45 | 
 46 |     /**
 47 |      * replaces task by ID
 48 |      *
 49 |      * @param $id
 50 |      * @param TaskInterface $task
 51 |      * @return bool
 52 |      */
 53 |     public function replace($id, TaskInterface $task)
 54 |     {
 55 |         // TODO: Implement replace() method.
 56 |     }
 57 | 
 58 |     /**
 59 |      * create file db or
 60 |      * db in any other place
 61 |      *
 62 |      * @return mixed
 63 |      */
 64 |     public function createDb()
 65 |     {
 66 |         if (is_dir($this->db_name)) {
 67 |             throw new \InvalidArgumentException('Directory with same name exists');
 68 |         }
 69 | 
 70 |         if (file_exists($this->db_name)) {
 71 |             return;
 72 |         }
 73 | 
 74 |         $resource = fopen($this->db_name, 'w');
 75 |         if (!$resource) {
 76 |             throw new \InvalidArgumentException('Cannot create store file in path ' . $this->db_name);
 77 |         }
 78 |     }
 79 | 
 80 |     /**
 81 |      * remove task from store
 82 |      *
 83 |      * @param $id
 84 |      * @return mixed
 85 |      */
 86 |     public function removeTaskById($id)
 87 |     {
 88 |         /** @var TaskInterface[] $tasks_with_removed_task */
 89 |         $tasks_with_removed_task = [];
 90 |         if (file_exists(($this->db_name))) {
 91 |             $lines = file($this->db_name);
 92 |             foreach ($lines as $line) {
 93 |                 $task = Task::fillTask(json_decode($line));
 94 |                 if ($task->getId() != $id) {
 95 |                     $tasks_with_removed_task[] = $task;
 96 |                 }
 97 |             }
 98 |         }
 99 | 
100 |         file_put_contents($this->db_name, '');
101 | 
102 |         foreach ($tasks_with_removed_task as $task) {
103 |             $this->write($task);
104 |         }
105 |     }
106 | }


--------------------------------------------------------------------------------
/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": "8c92c1465d18e42ea96612a3cf9efad2",
   8 |     "content-hash": "14e75a04f4832786fae4c66b1ab8df64",
   9 |     "packages": [],
  10 |     "packages-dev": [
  11 |         {
  12 |             "name": "doctrine/instantiator",
  13 |             "version": "1.0.5",
  14 |             "source": {
  15 |                 "type": "git",
  16 |                 "url": "https://github.com/doctrine/instantiator.git",
  17 |                 "reference": "8e884e78f9f0eb1329e445619e04456e64d8051d"
  18 |             },
  19 |             "dist": {
  20 |                 "type": "zip",
  21 |                 "url": "https://api.github.com/repos/doctrine/instantiator/zipball/8e884e78f9f0eb1329e445619e04456e64d8051d",
  22 |                 "reference": "8e884e78f9f0eb1329e445619e04456e64d8051d",
  23 |                 "shasum": ""
  24 |             },
  25 |             "require": {
  26 |                 "php": ">=5.3,<8.0-DEV"
  27 |             },
  28 |             "require-dev": {
  29 |                 "athletic/athletic": "~0.1.8",
  30 |                 "ext-pdo": "*",
  31 |                 "ext-phar": "*",
  32 |                 "phpunit/phpunit": "~4.0",
  33 |                 "squizlabs/php_codesniffer": "~2.0"
  34 |             },
  35 |             "type": "library",
  36 |             "extra": {
  37 |                 "branch-alias": {
  38 |                     "dev-master": "1.0.x-dev"
  39 |                 }
  40 |             },
  41 |             "autoload": {
  42 |                 "psr-4": {
  43 |                     "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/"
  44 |                 }
  45 |             },
  46 |             "notification-url": "https://packagist.org/downloads/",
  47 |             "license": [
  48 |                 "MIT"
  49 |             ],
  50 |             "authors": [
  51 |                 {
  52 |                     "name": "Marco Pivetta",
  53 |                     "email": "ocramius@gmail.com",
  54 |                     "homepage": "http://ocramius.github.com/"
  55 |                 }
  56 |             ],
  57 |             "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors",
  58 |             "homepage": "https://github.com/doctrine/instantiator",
  59 |             "keywords": [
  60 |                 "constructor",
  61 |                 "instantiate"
  62 |             ],
  63 |             "time": "2015-06-14 21:17:01"
  64 |         },
  65 |         {
  66 |             "name": "myclabs/deep-copy",
  67 |             "version": "1.5.0",
  68 |             "source": {
  69 |                 "type": "git",
  70 |                 "url": "https://github.com/myclabs/DeepCopy.git",
  71 |                 "reference": "e3abefcd7f106677fd352cd7c187d6c969aa9ddc"
  72 |             },
  73 |             "dist": {
  74 |                 "type": "zip",
  75 |                 "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/e3abefcd7f106677fd352cd7c187d6c969aa9ddc",
  76 |                 "reference": "e3abefcd7f106677fd352cd7c187d6c969aa9ddc",
  77 |                 "shasum": ""
  78 |             },
  79 |             "require": {
  80 |                 "php": ">=5.4.0"
  81 |             },
  82 |             "require-dev": {
  83 |                 "doctrine/collections": "1.*",
  84 |                 "phpunit/phpunit": "~4.1"
  85 |             },
  86 |             "type": "library",
  87 |             "autoload": {
  88 |                 "psr-4": {
  89 |                     "DeepCopy\\": "src/DeepCopy/"
  90 |                 }
  91 |             },
  92 |             "notification-url": "https://packagist.org/downloads/",
  93 |             "license": [
  94 |                 "MIT"
  95 |             ],
  96 |             "description": "Create deep copies (clones) of your objects",
  97 |             "homepage": "https://github.com/myclabs/DeepCopy",
  98 |             "keywords": [
  99 |                 "clone",
 100 |                 "copy",
 101 |                 "duplicate",
 102 |                 "object",
 103 |                 "object graph"
 104 |             ],
 105 |             "time": "2015-11-07 22:20:37"
 106 |         },
 107 |         {
 108 |             "name": "phpdocumentor/reflection-docblock",
 109 |             "version": "2.0.4",
 110 |             "source": {
 111 |                 "type": "git",
 112 |                 "url": "https://github.com/phpDocumentor/ReflectionDocBlock.git",
 113 |                 "reference": "d68dbdc53dc358a816f00b300704702b2eaff7b8"
 114 |             },
 115 |             "dist": {
 116 |                 "type": "zip",
 117 |                 "url": "https://api.github.com/repos/phpDocumentor/ReflectionDocBlock/zipball/d68dbdc53dc358a816f00b300704702b2eaff7b8",
 118 |                 "reference": "d68dbdc53dc358a816f00b300704702b2eaff7b8",
 119 |                 "shasum": ""
 120 |             },
 121 |             "require": {
 122 |                 "php": ">=5.3.3"
 123 |             },
 124 |             "require-dev": {
 125 |                 "phpunit/phpunit": "~4.0"
 126 |             },
 127 |             "suggest": {
 128 |                 "dflydev/markdown": "~1.0",
 129 |                 "erusev/parsedown": "~1.0"
 130 |             },
 131 |             "type": "library",
 132 |             "extra": {
 133 |                 "branch-alias": {
 134 |                     "dev-master": "2.0.x-dev"
 135 |                 }
 136 |             },
 137 |             "autoload": {
 138 |                 "psr-0": {
 139 |                     "phpDocumentor": [
 140 |                         "src/"
 141 |                     ]
 142 |                 }
 143 |             },
 144 |             "notification-url": "https://packagist.org/downloads/",
 145 |             "license": [
 146 |                 "MIT"
 147 |             ],
 148 |             "authors": [
 149 |                 {
 150 |                     "name": "Mike van Riel",
 151 |                     "email": "mike.vanriel@naenius.com"
 152 |                 }
 153 |             ],
 154 |             "time": "2015-02-03 12:10:50"
 155 |         },
 156 |         {
 157 |             "name": "phpspec/prophecy",
 158 |             "version": "v1.6.0",
 159 |             "source": {
 160 |                 "type": "git",
 161 |                 "url": "https://github.com/phpspec/prophecy.git",
 162 |                 "reference": "3c91bdf81797d725b14cb62906f9a4ce44235972"
 163 |             },
 164 |             "dist": {
 165 |                 "type": "zip",
 166 |                 "url": "https://api.github.com/repos/phpspec/prophecy/zipball/3c91bdf81797d725b14cb62906f9a4ce44235972",
 167 |                 "reference": "3c91bdf81797d725b14cb62906f9a4ce44235972",
 168 |                 "shasum": ""
 169 |             },
 170 |             "require": {
 171 |                 "doctrine/instantiator": "^1.0.2",
 172 |                 "php": "^5.3|^7.0",
 173 |                 "phpdocumentor/reflection-docblock": "~2.0",
 174 |                 "sebastian/comparator": "~1.1",
 175 |                 "sebastian/recursion-context": "~1.0"
 176 |             },
 177 |             "require-dev": {
 178 |                 "phpspec/phpspec": "~2.0"
 179 |             },
 180 |             "type": "library",
 181 |             "extra": {
 182 |                 "branch-alias": {
 183 |                     "dev-master": "1.5.x-dev"
 184 |                 }
 185 |             },
 186 |             "autoload": {
 187 |                 "psr-0": {
 188 |                     "Prophecy\\": "src/"
 189 |                 }
 190 |             },
 191 |             "notification-url": "https://packagist.org/downloads/",
 192 |             "license": [
 193 |                 "MIT"
 194 |             ],
 195 |             "authors": [
 196 |                 {
 197 |                     "name": "Konstantin Kudryashov",
 198 |                     "email": "ever.zet@gmail.com",
 199 |                     "homepage": "http://everzet.com"
 200 |                 },
 201 |                 {
 202 |                     "name": "Marcello Duarte",
 203 |                     "email": "marcello.duarte@gmail.com"
 204 |                 }
 205 |             ],
 206 |             "description": "Highly opinionated mocking framework for PHP 5.3+",
 207 |             "homepage": "https://github.com/phpspec/prophecy",
 208 |             "keywords": [
 209 |                 "Double",
 210 |                 "Dummy",
 211 |                 "fake",
 212 |                 "mock",
 213 |                 "spy",
 214 |                 "stub"
 215 |             ],
 216 |             "time": "2016-02-15 07:46:21"
 217 |         },
 218 |         {
 219 |             "name": "phpunit/php-code-coverage",
 220 |             "version": "3.3.0",
 221 |             "source": {
 222 |                 "type": "git",
 223 |                 "url": "https://github.com/sebastianbergmann/php-code-coverage.git",
 224 |                 "reference": "fe33716763b604ade4cb442c0794f5bd5ad73004"
 225 |             },
 226 |             "dist": {
 227 |                 "type": "zip",
 228 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/fe33716763b604ade4cb442c0794f5bd5ad73004",
 229 |                 "reference": "fe33716763b604ade4cb442c0794f5bd5ad73004",
 230 |                 "shasum": ""
 231 |             },
 232 |             "require": {
 233 |                 "php": "^5.6 || ^7.0",
 234 |                 "phpunit/php-file-iterator": "~1.3",
 235 |                 "phpunit/php-text-template": "~1.2",
 236 |                 "phpunit/php-token-stream": "^1.4.2",
 237 |                 "sebastian/code-unit-reverse-lookup": "~1.0",
 238 |                 "sebastian/environment": "^1.3.2",
 239 |                 "sebastian/version": "~1.0|~2.0"
 240 |             },
 241 |             "require-dev": {
 242 |                 "ext-xdebug": ">=2.1.4",
 243 |                 "phpunit/phpunit": "~5"
 244 |             },
 245 |             "suggest": {
 246 |                 "ext-dom": "*",
 247 |                 "ext-xdebug": ">=2.2.1",
 248 |                 "ext-xmlwriter": "*"
 249 |             },
 250 |             "type": "library",
 251 |             "extra": {
 252 |                 "branch-alias": {
 253 |                     "dev-master": "3.3.x-dev"
 254 |                 }
 255 |             },
 256 |             "autoload": {
 257 |                 "classmap": [
 258 |                     "src/"
 259 |                 ]
 260 |             },
 261 |             "notification-url": "https://packagist.org/downloads/",
 262 |             "license": [
 263 |                 "BSD-3-Clause"
 264 |             ],
 265 |             "authors": [
 266 |                 {
 267 |                     "name": "Sebastian Bergmann",
 268 |                     "email": "sb@sebastian-bergmann.de",
 269 |                     "role": "lead"
 270 |                 }
 271 |             ],
 272 |             "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.",
 273 |             "homepage": "https://github.com/sebastianbergmann/php-code-coverage",
 274 |             "keywords": [
 275 |                 "coverage",
 276 |                 "testing",
 277 |                 "xunit"
 278 |             ],
 279 |             "time": "2016-03-03 08:49:08"
 280 |         },
 281 |         {
 282 |             "name": "phpunit/php-file-iterator",
 283 |             "version": "1.4.1",
 284 |             "source": {
 285 |                 "type": "git",
 286 |                 "url": "https://github.com/sebastianbergmann/php-file-iterator.git",
 287 |                 "reference": "6150bf2c35d3fc379e50c7602b75caceaa39dbf0"
 288 |             },
 289 |             "dist": {
 290 |                 "type": "zip",
 291 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/6150bf2c35d3fc379e50c7602b75caceaa39dbf0",
 292 |                 "reference": "6150bf2c35d3fc379e50c7602b75caceaa39dbf0",
 293 |                 "shasum": ""
 294 |             },
 295 |             "require": {
 296 |                 "php": ">=5.3.3"
 297 |             },
 298 |             "type": "library",
 299 |             "extra": {
 300 |                 "branch-alias": {
 301 |                     "dev-master": "1.4.x-dev"
 302 |                 }
 303 |             },
 304 |             "autoload": {
 305 |                 "classmap": [
 306 |                     "src/"
 307 |                 ]
 308 |             },
 309 |             "notification-url": "https://packagist.org/downloads/",
 310 |             "license": [
 311 |                 "BSD-3-Clause"
 312 |             ],
 313 |             "authors": [
 314 |                 {
 315 |                     "name": "Sebastian Bergmann",
 316 |                     "email": "sb@sebastian-bergmann.de",
 317 |                     "role": "lead"
 318 |                 }
 319 |             ],
 320 |             "description": "FilterIterator implementation that filters files based on a list of suffixes.",
 321 |             "homepage": "https://github.com/sebastianbergmann/php-file-iterator/",
 322 |             "keywords": [
 323 |                 "filesystem",
 324 |                 "iterator"
 325 |             ],
 326 |             "time": "2015-06-21 13:08:43"
 327 |         },
 328 |         {
 329 |             "name": "phpunit/php-text-template",
 330 |             "version": "1.2.1",
 331 |             "source": {
 332 |                 "type": "git",
 333 |                 "url": "https://github.com/sebastianbergmann/php-text-template.git",
 334 |                 "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686"
 335 |             },
 336 |             "dist": {
 337 |                 "type": "zip",
 338 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
 339 |                 "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686",
 340 |                 "shasum": ""
 341 |             },
 342 |             "require": {
 343 |                 "php": ">=5.3.3"
 344 |             },
 345 |             "type": "library",
 346 |             "autoload": {
 347 |                 "classmap": [
 348 |                     "src/"
 349 |                 ]
 350 |             },
 351 |             "notification-url": "https://packagist.org/downloads/",
 352 |             "license": [
 353 |                 "BSD-3-Clause"
 354 |             ],
 355 |             "authors": [
 356 |                 {
 357 |                     "name": "Sebastian Bergmann",
 358 |                     "email": "sebastian@phpunit.de",
 359 |                     "role": "lead"
 360 |                 }
 361 |             ],
 362 |             "description": "Simple template engine.",
 363 |             "homepage": "https://github.com/sebastianbergmann/php-text-template/",
 364 |             "keywords": [
 365 |                 "template"
 366 |             ],
 367 |             "time": "2015-06-21 13:50:34"
 368 |         },
 369 |         {
 370 |             "name": "phpunit/php-timer",
 371 |             "version": "1.0.7",
 372 |             "source": {
 373 |                 "type": "git",
 374 |                 "url": "https://github.com/sebastianbergmann/php-timer.git",
 375 |                 "reference": "3e82f4e9fc92665fafd9157568e4dcb01d014e5b"
 376 |             },
 377 |             "dist": {
 378 |                 "type": "zip",
 379 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/3e82f4e9fc92665fafd9157568e4dcb01d014e5b",
 380 |                 "reference": "3e82f4e9fc92665fafd9157568e4dcb01d014e5b",
 381 |                 "shasum": ""
 382 |             },
 383 |             "require": {
 384 |                 "php": ">=5.3.3"
 385 |             },
 386 |             "type": "library",
 387 |             "autoload": {
 388 |                 "classmap": [
 389 |                     "src/"
 390 |                 ]
 391 |             },
 392 |             "notification-url": "https://packagist.org/downloads/",
 393 |             "license": [
 394 |                 "BSD-3-Clause"
 395 |             ],
 396 |             "authors": [
 397 |                 {
 398 |                     "name": "Sebastian Bergmann",
 399 |                     "email": "sb@sebastian-bergmann.de",
 400 |                     "role": "lead"
 401 |                 }
 402 |             ],
 403 |             "description": "Utility class for timing",
 404 |             "homepage": "https://github.com/sebastianbergmann/php-timer/",
 405 |             "keywords": [
 406 |                 "timer"
 407 |             ],
 408 |             "time": "2015-06-21 08:01:12"
 409 |         },
 410 |         {
 411 |             "name": "phpunit/php-token-stream",
 412 |             "version": "1.4.8",
 413 |             "source": {
 414 |                 "type": "git",
 415 |                 "url": "https://github.com/sebastianbergmann/php-token-stream.git",
 416 |                 "reference": "3144ae21711fb6cac0b1ab4cbe63b75ce3d4e8da"
 417 |             },
 418 |             "dist": {
 419 |                 "type": "zip",
 420 |                 "url": "https://api.github.com/repos/sebastianbergmann/php-token-stream/zipball/3144ae21711fb6cac0b1ab4cbe63b75ce3d4e8da",
 421 |                 "reference": "3144ae21711fb6cac0b1ab4cbe63b75ce3d4e8da",
 422 |                 "shasum": ""
 423 |             },
 424 |             "require": {
 425 |                 "ext-tokenizer": "*",
 426 |                 "php": ">=5.3.3"
 427 |             },
 428 |             "require-dev": {
 429 |                 "phpunit/phpunit": "~4.2"
 430 |             },
 431 |             "type": "library",
 432 |             "extra": {
 433 |                 "branch-alias": {
 434 |                     "dev-master": "1.4-dev"
 435 |                 }
 436 |             },
 437 |             "autoload": {
 438 |                 "classmap": [
 439 |                     "src/"
 440 |                 ]
 441 |             },
 442 |             "notification-url": "https://packagist.org/downloads/",
 443 |             "license": [
 444 |                 "BSD-3-Clause"
 445 |             ],
 446 |             "authors": [
 447 |                 {
 448 |                     "name": "Sebastian Bergmann",
 449 |                     "email": "sebastian@phpunit.de"
 450 |                 }
 451 |             ],
 452 |             "description": "Wrapper around PHP's tokenizer extension.",
 453 |             "homepage": "https://github.com/sebastianbergmann/php-token-stream/",
 454 |             "keywords": [
 455 |                 "tokenizer"
 456 |             ],
 457 |             "time": "2015-09-15 10:49:45"
 458 |         },
 459 |         {
 460 |             "name": "phpunit/phpunit",
 461 |             "version": "5.2.12",
 462 |             "source": {
 463 |                 "type": "git",
 464 |                 "url": "https://github.com/sebastianbergmann/phpunit.git",
 465 |                 "reference": "6f0948bab32270352f97d1913d82a49338dcb0da"
 466 |             },
 467 |             "dist": {
 468 |                 "type": "zip",
 469 |                 "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/6f0948bab32270352f97d1913d82a49338dcb0da",
 470 |                 "reference": "6f0948bab32270352f97d1913d82a49338dcb0da",
 471 |                 "shasum": ""
 472 |             },
 473 |             "require": {
 474 |                 "ext-dom": "*",
 475 |                 "ext-json": "*",
 476 |                 "ext-pcre": "*",
 477 |                 "ext-reflection": "*",
 478 |                 "ext-spl": "*",
 479 |                 "myclabs/deep-copy": "~1.3",
 480 |                 "php": "^5.6 || ^7.0",
 481 |                 "phpspec/prophecy": "^1.3.1",
 482 |                 "phpunit/php-code-coverage": "^3.3.0",
 483 |                 "phpunit/php-file-iterator": "~1.4",
 484 |                 "phpunit/php-text-template": "~1.2",
 485 |                 "phpunit/php-timer": ">=1.0.6",
 486 |                 "phpunit/phpunit-mock-objects": ">=3.0.5",
 487 |                 "sebastian/comparator": "~1.1",
 488 |                 "sebastian/diff": "~1.2",
 489 |                 "sebastian/environment": "~1.3",
 490 |                 "sebastian/exporter": "~1.2",
 491 |                 "sebastian/global-state": "~1.0",
 492 |                 "sebastian/resource-operations": "~1.0",
 493 |                 "sebastian/version": "~1.0|~2.0",
 494 |                 "symfony/yaml": "~2.1|~3.0"
 495 |             },
 496 |             "suggest": {
 497 |                 "phpunit/php-invoker": "~1.1"
 498 |             },
 499 |             "bin": [
 500 |                 "phpunit"
 501 |             ],
 502 |             "type": "library",
 503 |             "extra": {
 504 |                 "branch-alias": {
 505 |                     "dev-master": "5.2.x-dev"
 506 |                 }
 507 |             },
 508 |             "autoload": {
 509 |                 "classmap": [
 510 |                     "src/"
 511 |                 ]
 512 |             },
 513 |             "notification-url": "https://packagist.org/downloads/",
 514 |             "license": [
 515 |                 "BSD-3-Clause"
 516 |             ],
 517 |             "authors": [
 518 |                 {
 519 |                     "name": "Sebastian Bergmann",
 520 |                     "email": "sebastian@phpunit.de",
 521 |                     "role": "lead"
 522 |                 }
 523 |             ],
 524 |             "description": "The PHP Unit Testing framework.",
 525 |             "homepage": "https://phpunit.de/",
 526 |             "keywords": [
 527 |                 "phpunit",
 528 |                 "testing",
 529 |                 "xunit"
 530 |             ],
 531 |             "time": "2016-03-15 05:59:58"
 532 |         },
 533 |         {
 534 |             "name": "phpunit/phpunit-mock-objects",
 535 |             "version": "3.0.6",
 536 |             "source": {
 537 |                 "type": "git",
 538 |                 "url": "https://github.com/sebastianbergmann/phpunit-mock-objects.git",
 539 |                 "reference": "49bc700750196c04dd6bc2c4c99cb632b893836b"
 540 |             },
 541 |             "dist": {
 542 |                 "type": "zip",
 543 |                 "url": "https://api.github.com/repos/sebastianbergmann/phpunit-mock-objects/zipball/49bc700750196c04dd6bc2c4c99cb632b893836b",
 544 |                 "reference": "49bc700750196c04dd6bc2c4c99cb632b893836b",
 545 |                 "shasum": ""
 546 |             },
 547 |             "require": {
 548 |                 "doctrine/instantiator": "^1.0.2",
 549 |                 "php": ">=5.6",
 550 |                 "phpunit/php-text-template": "~1.2",
 551 |                 "sebastian/exporter": "~1.2"
 552 |             },
 553 |             "require-dev": {
 554 |                 "phpunit/phpunit": "~5"
 555 |             },
 556 |             "suggest": {
 557 |                 "ext-soap": "*"
 558 |             },
 559 |             "type": "library",
 560 |             "extra": {
 561 |                 "branch-alias": {
 562 |                     "dev-master": "3.0.x-dev"
 563 |                 }
 564 |             },
 565 |             "autoload": {
 566 |                 "classmap": [
 567 |                     "src/"
 568 |                 ]
 569 |             },
 570 |             "notification-url": "https://packagist.org/downloads/",
 571 |             "license": [
 572 |                 "BSD-3-Clause"
 573 |             ],
 574 |             "authors": [
 575 |                 {
 576 |                     "name": "Sebastian Bergmann",
 577 |                     "email": "sb@sebastian-bergmann.de",
 578 |                     "role": "lead"
 579 |                 }
 580 |             ],
 581 |             "description": "Mock Object library for PHPUnit",
 582 |             "homepage": "https://github.com/sebastianbergmann/phpunit-mock-objects/",
 583 |             "keywords": [
 584 |                 "mock",
 585 |                 "xunit"
 586 |             ],
 587 |             "time": "2015-12-08 08:47:06"
 588 |         },
 589 |         {
 590 |             "name": "sebastian/code-unit-reverse-lookup",
 591 |             "version": "1.0.0",
 592 |             "source": {
 593 |                 "type": "git",
 594 |                 "url": "https://github.com/sebastianbergmann/code-unit-reverse-lookup.git",
 595 |                 "reference": "c36f5e7cfce482fde5bf8d10d41a53591e0198fe"
 596 |             },
 597 |             "dist": {
 598 |                 "type": "zip",
 599 |                 "url": "https://api.github.com/repos/sebastianbergmann/code-unit-reverse-lookup/zipball/c36f5e7cfce482fde5bf8d10d41a53591e0198fe",
 600 |                 "reference": "c36f5e7cfce482fde5bf8d10d41a53591e0198fe",
 601 |                 "shasum": ""
 602 |             },
 603 |             "require": {
 604 |                 "php": ">=5.6"
 605 |             },
 606 |             "require-dev": {
 607 |                 "phpunit/phpunit": "~5"
 608 |             },
 609 |             "type": "library",
 610 |             "extra": {
 611 |                 "branch-alias": {
 612 |                     "dev-master": "1.0.x-dev"
 613 |                 }
 614 |             },
 615 |             "autoload": {
 616 |                 "classmap": [
 617 |                     "src/"
 618 |                 ]
 619 |             },
 620 |             "notification-url": "https://packagist.org/downloads/",
 621 |             "license": [
 622 |                 "BSD-3-Clause"
 623 |             ],
 624 |             "authors": [
 625 |                 {
 626 |                     "name": "Sebastian Bergmann",
 627 |                     "email": "sebastian@phpunit.de"
 628 |                 }
 629 |             ],
 630 |             "description": "Looks up which function or method a line of code belongs to",
 631 |             "homepage": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/",
 632 |             "time": "2016-02-13 06:45:14"
 633 |         },
 634 |         {
 635 |             "name": "sebastian/comparator",
 636 |             "version": "1.2.0",
 637 |             "source": {
 638 |                 "type": "git",
 639 |                 "url": "https://github.com/sebastianbergmann/comparator.git",
 640 |                 "reference": "937efb279bd37a375bcadf584dec0726f84dbf22"
 641 |             },
 642 |             "dist": {
 643 |                 "type": "zip",
 644 |                 "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/937efb279bd37a375bcadf584dec0726f84dbf22",
 645 |                 "reference": "937efb279bd37a375bcadf584dec0726f84dbf22",
 646 |                 "shasum": ""
 647 |             },
 648 |             "require": {
 649 |                 "php": ">=5.3.3",
 650 |                 "sebastian/diff": "~1.2",
 651 |                 "sebastian/exporter": "~1.2"
 652 |             },
 653 |             "require-dev": {
 654 |                 "phpunit/phpunit": "~4.4"
 655 |             },
 656 |             "type": "library",
 657 |             "extra": {
 658 |                 "branch-alias": {
 659 |                     "dev-master": "1.2.x-dev"
 660 |                 }
 661 |             },
 662 |             "autoload": {
 663 |                 "classmap": [
 664 |                     "src/"
 665 |                 ]
 666 |             },
 667 |             "notification-url": "https://packagist.org/downloads/",
 668 |             "license": [
 669 |                 "BSD-3-Clause"
 670 |             ],
 671 |             "authors": [
 672 |                 {
 673 |                     "name": "Jeff Welch",
 674 |                     "email": "whatthejeff@gmail.com"
 675 |                 },
 676 |                 {
 677 |                     "name": "Volker Dusch",
 678 |                     "email": "github@wallbash.com"
 679 |                 },
 680 |                 {
 681 |                     "name": "Bernhard Schussek",
 682 |                     "email": "bschussek@2bepublished.at"
 683 |                 },
 684 |                 {
 685 |                     "name": "Sebastian Bergmann",
 686 |                     "email": "sebastian@phpunit.de"
 687 |                 }
 688 |             ],
 689 |             "description": "Provides the functionality to compare PHP values for equality",
 690 |             "homepage": "http://www.github.com/sebastianbergmann/comparator",
 691 |             "keywords": [
 692 |                 "comparator",
 693 |                 "compare",
 694 |                 "equality"
 695 |             ],
 696 |             "time": "2015-07-26 15:48:44"
 697 |         },
 698 |         {
 699 |             "name": "sebastian/diff",
 700 |             "version": "1.4.1",
 701 |             "source": {
 702 |                 "type": "git",
 703 |                 "url": "https://github.com/sebastianbergmann/diff.git",
 704 |                 "reference": "13edfd8706462032c2f52b4b862974dd46b71c9e"
 705 |             },
 706 |             "dist": {
 707 |                 "type": "zip",
 708 |                 "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/13edfd8706462032c2f52b4b862974dd46b71c9e",
 709 |                 "reference": "13edfd8706462032c2f52b4b862974dd46b71c9e",
 710 |                 "shasum": ""
 711 |             },
 712 |             "require": {
 713 |                 "php": ">=5.3.3"
 714 |             },
 715 |             "require-dev": {
 716 |                 "phpunit/phpunit": "~4.8"
 717 |             },
 718 |             "type": "library",
 719 |             "extra": {
 720 |                 "branch-alias": {
 721 |                     "dev-master": "1.4-dev"
 722 |                 }
 723 |             },
 724 |             "autoload": {
 725 |                 "classmap": [
 726 |                     "src/"
 727 |                 ]
 728 |             },
 729 |             "notification-url": "https://packagist.org/downloads/",
 730 |             "license": [
 731 |                 "BSD-3-Clause"
 732 |             ],
 733 |             "authors": [
 734 |                 {
 735 |                     "name": "Kore Nordmann",
 736 |                     "email": "mail@kore-nordmann.de"
 737 |                 },
 738 |                 {
 739 |                     "name": "Sebastian Bergmann",
 740 |                     "email": "sebastian@phpunit.de"
 741 |                 }
 742 |             ],
 743 |             "description": "Diff implementation",
 744 |             "homepage": "https://github.com/sebastianbergmann/diff",
 745 |             "keywords": [
 746 |                 "diff"
 747 |             ],
 748 |             "time": "2015-12-08 07:14:41"
 749 |         },
 750 |         {
 751 |             "name": "sebastian/environment",
 752 |             "version": "1.3.5",
 753 |             "source": {
 754 |                 "type": "git",
 755 |                 "url": "https://github.com/sebastianbergmann/environment.git",
 756 |                 "reference": "dc7a29032cf72b54f36dac15a1ca5b3a1b6029bf"
 757 |             },
 758 |             "dist": {
 759 |                 "type": "zip",
 760 |                 "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/dc7a29032cf72b54f36dac15a1ca5b3a1b6029bf",
 761 |                 "reference": "dc7a29032cf72b54f36dac15a1ca5b3a1b6029bf",
 762 |                 "shasum": ""
 763 |             },
 764 |             "require": {
 765 |                 "php": ">=5.3.3"
 766 |             },
 767 |             "require-dev": {
 768 |                 "phpunit/phpunit": "~4.4"
 769 |             },
 770 |             "type": "library",
 771 |             "extra": {
 772 |                 "branch-alias": {
 773 |                     "dev-master": "1.3.x-dev"
 774 |                 }
 775 |             },
 776 |             "autoload": {
 777 |                 "classmap": [
 778 |                     "src/"
 779 |                 ]
 780 |             },
 781 |             "notification-url": "https://packagist.org/downloads/",
 782 |             "license": [
 783 |                 "BSD-3-Clause"
 784 |             ],
 785 |             "authors": [
 786 |                 {
 787 |                     "name": "Sebastian Bergmann",
 788 |                     "email": "sebastian@phpunit.de"
 789 |                 }
 790 |             ],
 791 |             "description": "Provides functionality to handle HHVM/PHP environments",
 792 |             "homepage": "http://www.github.com/sebastianbergmann/environment",
 793 |             "keywords": [
 794 |                 "Xdebug",
 795 |                 "environment",
 796 |                 "hhvm"
 797 |             ],
 798 |             "time": "2016-02-26 18:40:46"
 799 |         },
 800 |         {
 801 |             "name": "sebastian/exporter",
 802 |             "version": "1.2.1",
 803 |             "source": {
 804 |                 "type": "git",
 805 |                 "url": "https://github.com/sebastianbergmann/exporter.git",
 806 |                 "reference": "7ae5513327cb536431847bcc0c10edba2701064e"
 807 |             },
 808 |             "dist": {
 809 |                 "type": "zip",
 810 |                 "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/7ae5513327cb536431847bcc0c10edba2701064e",
 811 |                 "reference": "7ae5513327cb536431847bcc0c10edba2701064e",
 812 |                 "shasum": ""
 813 |             },
 814 |             "require": {
 815 |                 "php": ">=5.3.3",
 816 |                 "sebastian/recursion-context": "~1.0"
 817 |             },
 818 |             "require-dev": {
 819 |                 "phpunit/phpunit": "~4.4"
 820 |             },
 821 |             "type": "library",
 822 |             "extra": {
 823 |                 "branch-alias": {
 824 |                     "dev-master": "1.2.x-dev"
 825 |                 }
 826 |             },
 827 |             "autoload": {
 828 |                 "classmap": [
 829 |                     "src/"
 830 |                 ]
 831 |             },
 832 |             "notification-url": "https://packagist.org/downloads/",
 833 |             "license": [
 834 |                 "BSD-3-Clause"
 835 |             ],
 836 |             "authors": [
 837 |                 {
 838 |                     "name": "Jeff Welch",
 839 |                     "email": "whatthejeff@gmail.com"
 840 |                 },
 841 |                 {
 842 |                     "name": "Volker Dusch",
 843 |                     "email": "github@wallbash.com"
 844 |                 },
 845 |                 {
 846 |                     "name": "Bernhard Schussek",
 847 |                     "email": "bschussek@2bepublished.at"
 848 |                 },
 849 |                 {
 850 |                     "name": "Sebastian Bergmann",
 851 |                     "email": "sebastian@phpunit.de"
 852 |                 },
 853 |                 {
 854 |                     "name": "Adam Harvey",
 855 |                     "email": "aharvey@php.net"
 856 |                 }
 857 |             ],
 858 |             "description": "Provides the functionality to export PHP variables for visualization",
 859 |             "homepage": "http://www.github.com/sebastianbergmann/exporter",
 860 |             "keywords": [
 861 |                 "export",
 862 |                 "exporter"
 863 |             ],
 864 |             "time": "2015-06-21 07:55:53"
 865 |         },
 866 |         {
 867 |             "name": "sebastian/global-state",
 868 |             "version": "1.1.1",
 869 |             "source": {
 870 |                 "type": "git",
 871 |                 "url": "https://github.com/sebastianbergmann/global-state.git",
 872 |                 "reference": "bc37d50fea7d017d3d340f230811c9f1d7280af4"
 873 |             },
 874 |             "dist": {
 875 |                 "type": "zip",
 876 |                 "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/bc37d50fea7d017d3d340f230811c9f1d7280af4",
 877 |                 "reference": "bc37d50fea7d017d3d340f230811c9f1d7280af4",
 878 |                 "shasum": ""
 879 |             },
 880 |             "require": {
 881 |                 "php": ">=5.3.3"
 882 |             },
 883 |             "require-dev": {
 884 |                 "phpunit/phpunit": "~4.2"
 885 |             },
 886 |             "suggest": {
 887 |                 "ext-uopz": "*"
 888 |             },
 889 |             "type": "library",
 890 |             "extra": {
 891 |                 "branch-alias": {
 892 |                     "dev-master": "1.0-dev"
 893 |                 }
 894 |             },
 895 |             "autoload": {
 896 |                 "classmap": [
 897 |                     "src/"
 898 |                 ]
 899 |             },
 900 |             "notification-url": "https://packagist.org/downloads/",
 901 |             "license": [
 902 |                 "BSD-3-Clause"
 903 |             ],
 904 |             "authors": [
 905 |                 {
 906 |                     "name": "Sebastian Bergmann",
 907 |                     "email": "sebastian@phpunit.de"
 908 |                 }
 909 |             ],
 910 |             "description": "Snapshotting of global state",
 911 |             "homepage": "http://www.github.com/sebastianbergmann/global-state",
 912 |             "keywords": [
 913 |                 "global state"
 914 |             ],
 915 |             "time": "2015-10-12 03:26:01"
 916 |         },
 917 |         {
 918 |             "name": "sebastian/recursion-context",
 919 |             "version": "1.0.2",
 920 |             "source": {
 921 |                 "type": "git",
 922 |                 "url": "https://github.com/sebastianbergmann/recursion-context.git",
 923 |                 "reference": "913401df809e99e4f47b27cdd781f4a258d58791"
 924 |             },
 925 |             "dist": {
 926 |                 "type": "zip",
 927 |                 "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/913401df809e99e4f47b27cdd781f4a258d58791",
 928 |                 "reference": "913401df809e99e4f47b27cdd781f4a258d58791",
 929 |                 "shasum": ""
 930 |             },
 931 |             "require": {
 932 |                 "php": ">=5.3.3"
 933 |             },
 934 |             "require-dev": {
 935 |                 "phpunit/phpunit": "~4.4"
 936 |             },
 937 |             "type": "library",
 938 |             "extra": {
 939 |                 "branch-alias": {
 940 |                     "dev-master": "1.0.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": "Jeff Welch",
 955 |                     "email": "whatthejeff@gmail.com"
 956 |                 },
 957 |                 {
 958 |                     "name": "Sebastian Bergmann",
 959 |                     "email": "sebastian@phpunit.de"
 960 |                 },
 961 |                 {
 962 |                     "name": "Adam Harvey",
 963 |                     "email": "aharvey@php.net"
 964 |                 }
 965 |             ],
 966 |             "description": "Provides functionality to recursively process PHP variables",
 967 |             "homepage": "http://www.github.com/sebastianbergmann/recursion-context",
 968 |             "time": "2015-11-11 19:50:13"
 969 |         },
 970 |         {
 971 |             "name": "sebastian/resource-operations",
 972 |             "version": "1.0.0",
 973 |             "source": {
 974 |                 "type": "git",
 975 |                 "url": "https://github.com/sebastianbergmann/resource-operations.git",
 976 |                 "reference": "ce990bb21759f94aeafd30209e8cfcdfa8bc3f52"
 977 |             },
 978 |             "dist": {
 979 |                 "type": "zip",
 980 |                 "url": "https://api.github.com/repos/sebastianbergmann/resource-operations/zipball/ce990bb21759f94aeafd30209e8cfcdfa8bc3f52",
 981 |                 "reference": "ce990bb21759f94aeafd30209e8cfcdfa8bc3f52",
 982 |                 "shasum": ""
 983 |             },
 984 |             "require": {
 985 |                 "php": ">=5.6.0"
 986 |             },
 987 |             "type": "library",
 988 |             "extra": {
 989 |                 "branch-alias": {
 990 |                     "dev-master": "1.0.x-dev"
 991 |                 }
 992 |             },
 993 |             "autoload": {
 994 |                 "classmap": [
 995 |                     "src/"
 996 |                 ]
 997 |             },
 998 |             "notification-url": "https://packagist.org/downloads/",
 999 |             "license": [
1000 |                 "BSD-3-Clause"
1001 |             ],
1002 |             "authors": [
1003 |                 {
1004 |                     "name": "Sebastian Bergmann",
1005 |                     "email": "sebastian@phpunit.de"
1006 |                 }
1007 |             ],
1008 |             "description": "Provides a list of PHP built-in functions that operate on resources",
1009 |             "homepage": "https://www.github.com/sebastianbergmann/resource-operations",
1010 |             "time": "2015-07-28 20:34:47"
1011 |         },
1012 |         {
1013 |             "name": "sebastian/version",
1014 |             "version": "2.0.0",
1015 |             "source": {
1016 |                 "type": "git",
1017 |                 "url": "https://github.com/sebastianbergmann/version.git",
1018 |                 "reference": "c829badbd8fdf16a0bad8aa7fa7971c029f1b9c5"
1019 |             },
1020 |             "dist": {
1021 |                 "type": "zip",
1022 |                 "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/c829badbd8fdf16a0bad8aa7fa7971c029f1b9c5",
1023 |                 "reference": "c829badbd8fdf16a0bad8aa7fa7971c029f1b9c5",
1024 |                 "shasum": ""
1025 |             },
1026 |             "require": {
1027 |                 "php": ">=5.6"
1028 |             },
1029 |             "type": "library",
1030 |             "extra": {
1031 |                 "branch-alias": {
1032 |                     "dev-master": "2.0.x-dev"
1033 |                 }
1034 |             },
1035 |             "autoload": {
1036 |                 "classmap": [
1037 |                     "src/"
1038 |                 ]
1039 |             },
1040 |             "notification-url": "https://packagist.org/downloads/",
1041 |             "license": [
1042 |                 "BSD-3-Clause"
1043 |             ],
1044 |             "authors": [
1045 |                 {
1046 |                     "name": "Sebastian Bergmann",
1047 |                     "email": "sebastian@phpunit.de",
1048 |                     "role": "lead"
1049 |                 }
1050 |             ],
1051 |             "description": "Library that helps with managing the version number of Git-hosted PHP projects",
1052 |             "homepage": "https://github.com/sebastianbergmann/version",
1053 |             "time": "2016-02-04 12:56:52"
1054 |         },
1055 |         {
1056 |             "name": "symfony/yaml",
1057 |             "version": "v3.0.3",
1058 |             "source": {
1059 |                 "type": "git",
1060 |                 "url": "https://github.com/symfony/yaml.git",
1061 |                 "reference": "b5ba64cd67ecd6887f63868fa781ca094bd1377c"
1062 |             },
1063 |             "dist": {
1064 |                 "type": "zip",
1065 |                 "url": "https://api.github.com/repos/symfony/yaml/zipball/b5ba64cd67ecd6887f63868fa781ca094bd1377c",
1066 |                 "reference": "b5ba64cd67ecd6887f63868fa781ca094bd1377c",
1067 |                 "shasum": ""
1068 |             },
1069 |             "require": {
1070 |                 "php": ">=5.5.9"
1071 |             },
1072 |             "type": "library",
1073 |             "extra": {
1074 |                 "branch-alias": {
1075 |                     "dev-master": "3.0-dev"
1076 |                 }
1077 |             },
1078 |             "autoload": {
1079 |                 "psr-4": {
1080 |                     "Symfony\\Component\\Yaml\\": ""
1081 |                 },
1082 |                 "exclude-from-classmap": [
1083 |                     "/Tests/"
1084 |                 ]
1085 |             },
1086 |             "notification-url": "https://packagist.org/downloads/",
1087 |             "license": [
1088 |                 "MIT"
1089 |             ],
1090 |             "authors": [
1091 |                 {
1092 |                     "name": "Fabien Potencier",
1093 |                     "email": "fabien@symfony.com"
1094 |                 },
1095 |                 {
1096 |                     "name": "Symfony Community",
1097 |                     "homepage": "https://symfony.com/contributors"
1098 |                 }
1099 |             ],
1100 |             "description": "Symfony Yaml Component",
1101 |             "homepage": "https://symfony.com",
1102 |             "time": "2016-02-23 15:16:06"
1103 |         }
1104 |     ],
1105 |     "aliases": [],
1106 |     "minimum-stability": "stable",
1107 |     "stability-flags": [],
1108 |     "prefer-stable": false,
1109 |     "prefer-lowest": false,
1110 |     "platform": [],
1111 |     "platform-dev": []
1112 | }
1113 | 


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