First commit

Author: mnapoli

.gitattributes

@@ -0,0 +1,6 @@
+# .gitattributes
+tests/ export-ignore
+.travis.yml export-ignore
+
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+.idea/*
+vendor/*
+composer.phar
+composer.lock

.travis.yml

@@ -0,0 +1,16 @@
+language: php
+
+php:
+  - 5.4
+  - 5.5
+
+before_script:
+  - wget http://getcomposer.org/composer.phar
+  - php composer.phar require satooshi/php-coveralls:dev-master --dev --no-progress --prefer-source
+
+script:
+  - mkdir -p build/logs
+  - phpunit --coverage-clover build/logs/clover.xml
+
+after_script:
+  - php vendor/bin/coveralls -v

LICENSE

@@ -0,0 +1,18 @@
+The MIT License (MIT)
+
+Copyright (C) 2013 My C-Sense
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,84 @@
+PHP-DI is a Container that makes [*Dependency Injection*](http://en.wikipedia.org/wiki/Dependency_injection)
+as practical as possible.
+
+PHP-DI also tries to avoid falling into the trap of the "Service Locator" antipattern and help you do *real* dependency injection.
+
+[![Latest Stable Version](https://poser.pugx.org/mnapoli/php-di/v/stable.png)](https://packagist.org/packages/mnapoli/php-di) [![Total Downloads](https://poser.pugx.org/mnapoli/php-di/downloads.png)](https://packagist.org/packages/mnapoli/php-di)
+
+
+## Features
+
+* Simple to start with
+* Supports different configuration alternatives to suit every taste:
+    * **Reflection**: zero configuration, intelligent guessing
+    * **Annotations**: modern, practical and simple
+    * **PHP code**: if you like complete control and auto-completion
+    * **PHP array**: allows you to store it in a configuration file
+    * **YAML**: elegant and concise
+* **Performances**: supports a large number of Caches
+* Lazy injection: lazy-loading of dependencies
+* Supports constructor injection, setter injection and property injection
+* Easy integration with any framework with [Injection over an existing instance](doc/inject-on-instance.md)
+
+
+## Usage
+
+Let's go to the [Getting started guide](doc/getting-started.md)!
+
+And there is a [complete documentation](doc/) waiting for you.
+
+
+## What is dependency injection, and why use PHP-DI
+
+You can first read the [introduction to dependency injection with an example](doc/example.md).
+
+Dependency injection and DI containers are separate notions, and one should use of a container only if it makes things more practical (which is not always the case depending on the container you use).
+
+PHP-DI is about this: make dependency injection more practical.
+
+### How classic PHP code works
+
+Here is how a code **not** using DI will roughly work:
+
+* Application needs Foo (e.g. a controller), so:
+* Application creates Foo
+* Application calls Foo
+    * Foo needs Bar (e.g. a service), so:
+    * Foo creates Bar
+    * Foo calls Bar
+        * Bar needs Bim (a service, a repository, …), so:
+        * Bar creates Bim
+        * Bar does something
+
+### How Dependency Injection works
+
+Here is how a code using DI will roughly work:
+
+* Application needs Foo, which needs Bar, which needs Bim, so:
+* Application creates Bim
+* Application creates Bar and gives it Bim
+* Application creates Foo and gives it Bar
+* Application calls Foo
+    * Foo calls Bar
+        * Bar does something
+
+This is the pattern of **Inversion of Control**. The control of the dependencies is **inversed** from one being called to the one calling.
+
+The main advantage: the one at the end of the caller chain is always **you**. So you can control every dependencies: you have a complete control on how your application works. You can replace a dependency by another (one you made for example).
+
+For example that wouldn't be so easy if Library X uses Logger Y and you have to change the code of Library X to make it use your logger Z.
+
+### How code using PHP-DI works
+
+Now how does a code using PHP-DI works:
+
+* Application needs Foo so:
+* Application gets Foo from the Container, so:
+    * Container creates Bim
+    * Container creates Bar and gives it Bim
+    * Container creates Foo and gives it Bar
+* Application calls Foo
+    * Foo calls Bar
+        * Bar does something
+
+In short, PHP-DI takes away all the work of creating and injecting dependencies.

composer.json

@@ -0,0 +1,18 @@
+{
+    "name": "myclabs/work",
+    "type": "library",
+    "description": "Generic work queue library",
+    "keywords": ["work", "work queue", "rabbitmq"],
+    "license": "MIT",
+    "autoload": {
+        "psr-0": {
+            "MyCLabs": "src/",
+            "UnitTest": "tests/"
+        }
+    },
+    "require": {
+        "php": ">=5.4.0",
+        "psr/log": "~1.0",
+        "videlalvaro/php-amqplib": "~2.0"
+    }
+}

phpunit.xml.dist

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         syntaxCheck="false"
+         bootstrap="./tests/bootstrap.php">
+
+    <testsuites>
+        <testsuite name="Work unit tests">
+            <directory>./tests/UnitTest/</directory>
+        </testsuite>
+    </testsuites>
+
+</phpunit>

src/MyCLabs/Work/Dispatcher/SimpleWorkDispatcher.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace MyCLabs\Work\Dispatcher;
+
+use MyCLabs\Work\Task\Task;
+
+/**
+ * Simple implementation not using any work queue: tasks are executed right away in the same process.
+ *
+ * @author Matthieu Napoli <[email protected]>
+ */
+class SimpleWorkDispatcher implements WorkDispatcher
+{
+    /**
+     * Workers indexés par le nom de la tâche qu'ils traitent
+     * @var Worker[]
+     */
+    private $workers = [];
+
+    /**
+     * {@inheritdoc}
+     */
+    public function runBackground(Task $task)
+    {
+        $worker = $this->getWorker($task);
+
+        $worker->execute($task);
+    }
+
+    /**
+     * Retourne le worker enregistré pour une tâche donnée
+     * @param Task $task
+     * @return Worker|null
+     */
+    private function getWorker(Task $task)
+    {
+        $taskType = get_class($task);
+
+        if (array_key_exists($taskType, $this->workers)) {
+            return $this->workers[$taskType];
+        }
+
+        return null;
+    }
+}

src/MyCLabs/Work/Dispatcher/WorkDispatcher.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace MyCLabs\Work\Dispatcher;
+
+use MyCLabs\Work\Task\Task;
+
+/**
+ * Dispatch tasks.
+ *
+ * @author Matthieu Napoli <[email protected]>
+ */
+interface WorkDispatcher
+{
+    /**
+     * Run a task in background
+     *
+     * @param Task $task
+     * @return void No results
+     */
+    public function runBackground(Task $task);
+}

src/MyCLabs/Work/Task/ServiceCall.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace MyCLabs\Work\Task;
+
+/**
+ * Represents the call of the method of a service.
+ *
+ * @author Matthieu Napoli <[email protected]>
+ */
+class ServiceCall implements Task
+{
+    /**
+     * @var string
+     */
+    private $serviceName;
+
+    /**
+     * @var string
+     */
+    private $methodName;
+
+    /**
+     * @var array
+     */
+    private $parameters;
+
+    /**
+     * @param string $serviceName Name of the service class
+     * @param string $methodName  Name of the method to call
+     * @param array  $parameters  Parameters for the method call, must be serializable
+     */
+    public function __construct($serviceName, $methodName, array $parameters = [])
+    {
+        $this->serviceName = $serviceName;
+        $this->methodName = $methodName;
+        $this->parameters = $parameters;
+    }
+
+    /**
+     * @return string
+     */
+    public function getServiceName()
+    {
+        return $this->serviceName;
+    }
+
+    /**
+     * @return string
+     */
+    public function getMethodName()
+    {
+        return $this->methodName;
+    }
+
+    /**
+     * @return array
+     */
+    public function getParameters()
+    {
+        return $this->parameters;
+    }
+}