Actualización

vendor/pimple/pimple/.gitignore

@@ -0,0 +1 @@
+phpunit.xml

vendor/pimple/pimple/.travis.yml

@@ -0,0 +1,6 @@
+language: php
+
+php:
+  - 5.3
+  - 5.4
+  - 5.5

vendor/pimple/pimple/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009-2013 Fabien Potencier
+
+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.

vendor/pimple/pimple/README.rst

@@ -0,0 +1,159 @@
+Pimple
+======
+
+Pimple is a small Dependency Injection Container for PHP 5.3 that consists
+of just one file and one class (about 80 lines of code).
+
+`Download it`_, require it in your code, and you're good to go::
+
+    require_once '/path/to/Pimple.php';
+
+Creating a container is a matter of instating the ``Pimple`` class::
+
+    $container = new Pimple();
+
+As many other dependency injection containers, Pimple is able to manage two
+different kind of data: *services* and *parameters*.
+
+Defining Parameters
+-------------------
+
+Defining a parameter is as simple as using the Pimple instance as an array::
+
+    // define some parameters
+    $container['cookie_name'] = 'SESSION_ID';
+    $container['session_storage_class'] = 'SessionStorage';
+
+Defining Services
+-----------------
+
+A service is an object that does something as part of a larger system.
+Examples of services: Database connection, templating engine, mailer. Almost
+any object could be a service.
+
+Services are defined by anonymous functions that return an instance of an
+object::
+
+    // define some services
+    $container['session_storage'] = function ($c) {
+        return new $c['session_storage_class']($c['cookie_name']);
+    };
+
+    $container['session'] = function ($c) {
+        return new Session($c['session_storage']);
+    };
+
+Notice that the anonymous function has access to the current container
+instance, allowing references to other services or parameters.
+
+As objects are only created when you get them, the order of the definitions
+does not matter, and there is no performance penalty.
+
+Using the defined services is also very easy::
+
+    // get the session object
+    $session = $container['session'];
+
+    // the above call is roughly equivalent to the following code:
+    // $storage = new SessionStorage('SESSION_ID');
+    // $session = new Session($storage);
+
+Defining Shared Services
+------------------------
+
+By default, each time you get a service, Pimple returns a new instance of it.
+If you want the same instance to be returned for all calls, wrap your
+anonymous function with the ``share()`` method::
+
+    $container['session'] = $container->share(function ($c) {
+        return new Session($c['session_storage']);
+    });
+
+Protecting Parameters
+---------------------
+
+Because Pimple sees anonymous functions as service definitions, you need to
+wrap anonymous functions with the ``protect()`` method to store them as
+parameter::
+
+    $container['random'] = $container->protect(function () { return rand(); });
+
+Modifying services after creation
+---------------------------------
+
+In some cases you may want to modify a service definition after it has been
+defined. You can use the ``extend()`` method to define additional code to
+be run on your service just after it is created::
+
+    $container['mail'] = function ($c) {
+        return new \Zend_Mail();
+    };
+
+    $container['mail'] = $container->extend('mail', function($mail, $c) {
+        $mail->setFrom($c['mail.default_from']);
+        return $mail;
+    });
+
+The first argument is the name of the object, the second is a function that
+gets access to the object instance and the container. The return value is
+a service definition, so you need to re-assign it on the container.
+
+If the service you plan to extend is already shared, it's recommended that you
+re-wrap your extended service with the ``shared`` method, otherwise your extension
+code will be called every time you access the service::
+
+    $container['twig'] = $container->share(function ($c) {
+        return new Twig_Environment($c['twig.loader'], $c['twig.options']);
+    });
+
+    $container['twig'] = $container->share($container->extend('twig', function ($twig, $c) {
+        $twig->addExtension(new MyTwigExtension());
+        return $twig;
+    }));
+
+Fetching the service creation function
+--------------------------------------
+
+When you access an object, Pimple automatically calls the anonymous function
+that you defined, which creates the service object for you. If you want to get
+raw access to this function, you can use the ``raw()`` method::
+
+    $container['session'] = $container->share(function ($c) {
+        return new Session($c['session_storage']);
+    });
+
+    $sessionFunction = $container->raw('session');
+
+Packaging a Container for reusability
+-------------------------------------
+
+If you use the same libraries over and over, you might want to create reusable
+containers. Creating a reusable container is as simple as creating a class
+that extends ``Pimple``, and configuring it in the constructor::
+
+    class SomeContainer extends Pimple
+    {
+        public function __construct()
+        {
+            $this['parameter'] = 'foo';
+            $this['object'] = function () { return stdClass(); };
+        }
+    }
+
+Using this container from your own is as easy as it can get::
+
+    $container = new Pimple();
+
+    // define your project parameters and services
+    // ...
+
+    // embed the SomeContainer container
+    $container['embedded'] = $container->share(function () { return new SomeContainer(); });
+
+    // configure it
+    $container['embedded']['parameter'] = 'bar';
+
+    // use it
+    $container['embedded']['object']->...;
+
+.. _Download it: https://github.com/fabpot/Pimple

vendor/pimple/pimple/composer.json

@@ -0,0 +1,25 @@
+{
+    "name": "pimple/pimple",
+    "type": "library",
+    "description": "Pimple is a simple Dependency Injection Container for PHP 5.3",
+    "keywords": ["dependency injection", "container"],
+    "homepage": "http://pimple.sensiolabs.org",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Fabien Potencier",
+            "email": "fabien@symfony.com"
+        }
+    ],
+    "require": {
+        "php": ">=5.3.0"
+    },
+    "autoload": {
+        "psr-0": { "Pimple": "lib/" }
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-master": "1.1.x-dev"
+        }
+    }
+}

vendor/pimple/pimple/lib/Pimple.php

@@ -0,0 +1,214 @@
+<?php
+
+/*
+ * This file is part of Pimple.
+ *
+ * Copyright (c) 2009 Fabien Potencier
+ *
+ * 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.
+ */
+
+/**
+ * Pimple main class.
+ *
+ * @package pimple
+ * @author  Fabien Potencier
+ */
+class Pimple implements ArrayAccess
+{
+    protected $values = array();
+
+    /**
+     * Instantiate the container.
+     *
+     * Objects and parameters can be passed as argument to the constructor.
+     *
+     * @param array $values The parameters or objects.
+     */
+    public function __construct(array $values = array())
+    {
+        $this->values = $values;
+    }
+
+    /**
+     * Sets a parameter or an object.
+     *
+     * Objects must be defined as Closures.
+     *
+     * Allowing any PHP callable leads to difficult to debug problems
+     * as function names (strings) are callable (creating a function with
+     * the same a name as an existing parameter would break your container).
+     *
+     * @param string $id    The unique identifier for the parameter or object
+     * @param mixed  $value The value of the parameter or a closure to defined an object
+     */
+    public function offsetSet($id, $value)
+    {
+        $this->values[$id] = $value;
+    }
+
+    /**
+     * Gets a parameter or an object.
+     *
+     * @param string $id The unique identifier for the parameter or object
+     *
+     * @return mixed The value of the parameter or an object
+     *
+     * @throws InvalidArgumentException if the identifier is not defined
+     */
+    public function offsetGet($id)
+    {
+        if (!array_key_exists($id, $this->values)) {
+            throw new InvalidArgumentException(sprintf('Identifier "%s" is not defined.', $id));
+        }
+
+        $isFactory = is_object($this->values[$id]) && method_exists($this->values[$id], '__invoke');
+
+        return $isFactory ? $this->values[$id]($this) : $this->values[$id];
+    }
+
+    /**
+     * Checks if a parameter or an object is set.
+     *
+     * @param string $id The unique identifier for the parameter or object
+     *
+     * @return Boolean
+     */
+    public function offsetExists($id)
+    {
+        return array_key_exists($id, $this->values);
+    }
+
+    /**
+     * Unsets a parameter or an object.
+     *
+     * @param string $id The unique identifier for the parameter or object
+     */
+    public function offsetUnset($id)
+    {
+        unset($this->values[$id]);
+    }
+
+    /**
+     * Returns a closure that stores the result of the given service definition
+     * for uniqueness in the scope of this instance of Pimple.
+     *
+     * @param callable $callable A service definition to wrap for uniqueness
+     *
+     * @return Closure The wrapped closure
+     */
+    public static function share($callable)
+    {
+        if (!is_object($callable) || !method_exists($callable, '__invoke')) {
+            throw new InvalidArgumentException('Service definition is not a Closure or invokable object.');
+        }
+
+        return function ($c) use ($callable) {
+            static $object;
+
+            if (null === $object) {
+                $object = $callable($c);
+            }
+
+            return $object;
+        };
+    }
+
+    /**
+     * Protects a callable from being interpreted as a service.
+     *
+     * This is useful when you want to store a callable as a parameter.
+     *
+     * @param callable $callable A callable to protect from being evaluated
+     *
+     * @return Closure The protected closure
+     */
+    public static function protect($callable)
+    {
+        if (!is_object($callable) || !method_exists($callable, '__invoke')) {
+            throw new InvalidArgumentException('Callable is not a Closure or invokable object.');
+        }
+
+        return function ($c) use ($callable) {
+            return $callable;
+        };
+    }
+
+    /**
+     * Gets a parameter or the closure defining an object.
+     *
+     * @param string $id The unique identifier for the parameter or object
+     *
+     * @return mixed The value of the parameter or the closure defining an object
+     *
+     * @throws InvalidArgumentException if the identifier is not defined
+     */
+    public function raw($id)
+    {
+        if (!array_key_exists($id, $this->values)) {
+            throw new InvalidArgumentException(sprintf('Identifier "%s" is not defined.', $id));
+        }
+
+        return $this->values[$id];
+    }
+
+    /**
+     * Extends an object definition.
+     *
+     * Useful when you want to extend an existing object definition,
+     * without necessarily loading that object.
+     *
+     * @param string $id       The unique identifier for the object
+     * @param callable $callable A service definition to extend the original
+     *
+     * @return Closure The wrapped closure
+     *
+     * @throws InvalidArgumentException if the identifier is not defined or not a service definition
+     */
+    public function extend($id, $callable)
+    {
+        if (!array_key_exists($id, $this->values)) {
+            throw new InvalidArgumentException(sprintf('Identifier "%s" is not defined.', $id));
+        }
+
+        if (!is_object($this->values[$id]) || !method_exists($this->values[$id], '__invoke')) {
+            throw new InvalidArgumentException(sprintf('Identifier "%s" does not contain an object definition.', $id));
+        }
+
+        if (!is_object($callable) || !method_exists($callable, '__invoke')) {
+            throw new InvalidArgumentException('Extension service definition is not a Closure or invokable object.');
+        }
+
+        $factory = $this->values[$id];
+
+        return $this->values[$id] = function ($c) use ($callable, $factory) {
+            return $callable($factory($c), $c);
+        };
+    }
+
+    /**
+     * Returns all defined value names.
+     *
+     * @return array An array of value names
+     */
+    public function keys()
+    {
+        return array_keys($this->values);
+    }
+}

vendor/pimple/pimple/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="Pimple Test Suite">
+            <directory>./tests/Pimple/</directory>
+        </testsuite>
+    </testsuites>
+</phpunit>

vendor/pimple/pimple/tests/Pimple/Tests/Invokable.php

@@ -0,0 +1,38 @@
+<?php
+
+/*
+ * This file is part of Pimple.
+ *
+ * Copyright (c) 2009 Fabien Potencier
+ *
+ * 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.
+ */
+
+namespace Pimple\Tests;
+
+class Invokable
+{
+    public function __invoke($value = null)
+    {
+        $service = new Service();
+        $service->value = $value;
+
+        return $service;
+    }
+}

vendor/pimple/pimple/tests/Pimple/Tests/NonInvokable.php

@@ -0,0 +1,34 @@
+<?php
+
+/*
+ * This file is part of Pimple.
+ *
+ * Copyright (c) 2009 Fabien Potencier
+ *
+ * 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.
+ */
+
+namespace Pimple\Tests;
+
+class NonInvokable
+{
+    public function __call($a, $b)
+    {
+    }
+}

vendor/pimple/pimple/tests/Pimple/Tests/PimpleTest.php

@@ -0,0 +1,331 @@
+<?php
+
+/*
+ * This file is part of Pimple.
+ *
+ * Copyright (c) 2009 Fabien Potencier
+ *
+ * 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.
+ */
+
+namespace Pimple\Tests;
+
+use Pimple;
+
+/**
+ * Pimple Test
+ *
+ * @package pimple
+ * @author  Igor Wiedler <igor@wiedler.ch>
+ */
+class PimpleTest extends \PHPUnit_Framework_TestCase
+{
+    public function testWithString()
+    {
+        $pimple = new Pimple();
+        $pimple['param'] = 'value';
+
+        $this->assertEquals('value', $pimple['param']);
+    }
+
+    public function testWithClosure()
+    {
+        $pimple = new Pimple();
+        $pimple['service'] = function () {
+            return new Service();
+        };
+
+        $this->assertInstanceOf('Pimple\Tests\Service', $pimple['service']);
+    }
+
+    public function testServicesShouldBeDifferent()
+    {
+        $pimple = new Pimple();
+        $pimple['service'] = function () {
+            return new Service();
+        };
+
+        $serviceOne = $pimple['service'];
+        $this->assertInstanceOf('Pimple\Tests\Service', $serviceOne);
+
+        $serviceTwo = $pimple['service'];
+        $this->assertInstanceOf('Pimple\Tests\Service', $serviceTwo);
+
+        $this->assertNotSame($serviceOne, $serviceTwo);
+    }
+
+    public function testShouldPassContainerAsParameter()
+    {
+        $pimple = new Pimple();
+        $pimple['service'] = function () {
+            return new Service();
+        };
+        $pimple['container'] = function ($container) {
+            return $container;
+        };
+
+        $this->assertNotSame($pimple, $pimple['service']);
+        $this->assertSame($pimple, $pimple['container']);
+    }
+
+    public function testIsset()
+    {
+        $pimple = new Pimple();
+        $pimple['param'] = 'value';
+        $pimple['service'] = function () {
+            return new Service();
+        };
+
+        $pimple['null'] = null;
+
+        $this->assertTrue(isset($pimple['param']));
+        $this->assertTrue(isset($pimple['service']));
+        $this->assertTrue(isset($pimple['null']));
+        $this->assertFalse(isset($pimple['non_existent']));
+    }
+
+    public function testConstructorInjection()
+    {
+        $params = array("param" => "value");
+        $pimple = new Pimple($params);
+
+        $this->assertSame($params['param'], $pimple['param']);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Identifier "foo" is not defined.
+     */
+    public function testOffsetGetValidatesKeyIsPresent()
+    {
+        $pimple = new Pimple();
+        echo $pimple['foo'];
+    }
+
+    public function testOffsetGetHonorsNullValues()
+    {
+        $pimple = new Pimple();
+        $pimple['foo'] = null;
+        $this->assertNull($pimple['foo']);
+    }
+
+    public function testUnset()
+    {
+        $pimple = new Pimple();
+        $pimple['param'] = 'value';
+        $pimple['service'] = function () {
+            return new Service();
+        };
+
+        unset($pimple['param'], $pimple['service']);
+        $this->assertFalse(isset($pimple['param']));
+        $this->assertFalse(isset($pimple['service']));
+    }
+
+    /**
+     * @dataProvider serviceDefinitionProvider
+     */
+    public function testShare($service)
+    {
+        $pimple = new Pimple();
+        $pimple['shared_service'] = $pimple->share($service);
+
+        $serviceOne = $pimple['shared_service'];
+        $this->assertInstanceOf('Pimple\Tests\Service', $serviceOne);
+
+        $serviceTwo = $pimple['shared_service'];
+        $this->assertInstanceOf('Pimple\Tests\Service', $serviceTwo);
+
+        $this->assertSame($serviceOne, $serviceTwo);
+    }
+
+    /**
+     * @dataProvider serviceDefinitionProvider
+     */
+    public function testProtect($service)
+    {
+        $pimple = new Pimple();
+        $pimple['protected'] = $pimple->protect($service);
+
+        $this->assertSame($service, $pimple['protected']);
+    }
+
+    public function testGlobalFunctionNameAsParameterValue()
+    {
+        $pimple = new Pimple();
+        $pimple['global_function'] = 'strlen';
+        $this->assertSame('strlen', $pimple['global_function']);
+    }
+
+    public function testRaw()
+    {
+        $pimple = new Pimple();
+        $pimple['service'] = $definition = function () { return 'foo'; };
+        $this->assertSame($definition, $pimple->raw('service'));
+    }
+
+    public function testRawHonorsNullValues()
+    {
+        $pimple = new Pimple();
+        $pimple['foo'] = null;
+        $this->assertNull($pimple->raw('foo'));
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Identifier "foo" is not defined.
+     */
+    public function testRawValidatesKeyIsPresent()
+    {
+        $pimple = new Pimple();
+        $pimple->raw('foo');
+    }
+
+    /**
+     * @dataProvider serviceDefinitionProvider
+     */
+    public function testExtend($service)
+    {
+        $pimple = new Pimple();
+        $pimple['shared_service'] = $pimple->share(function () {
+            return new Service();
+        });
+
+        $pimple->extend('shared_service', $service);
+
+        $serviceOne = $pimple['shared_service'];
+        $this->assertInstanceOf('Pimple\Tests\Service', $serviceOne);
+
+        $serviceTwo = $pimple['shared_service'];
+        $this->assertInstanceOf('Pimple\Tests\Service', $serviceTwo);
+
+        $this->assertNotSame($serviceOne, $serviceTwo);
+        $this->assertSame($serviceOne->value, $serviceTwo->value);
+    }
+
+    /**
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Identifier "foo" is not defined.
+     */
+    public function testExtendValidatesKeyIsPresent()
+    {
+        $pimple = new Pimple();
+        $pimple->extend('foo', function () {});
+    }
+
+    public function testKeys()
+    {
+        $pimple = new Pimple();
+        $pimple['foo'] = 123;
+        $pimple['bar'] = 123;
+
+        $this->assertEquals(array('foo', 'bar'), $pimple->keys());
+    }
+
+    /** @test */
+    public function settingAnInvokableObjectShouldTreatItAsFactory()
+    {
+        $pimple = new Pimple();
+        $pimple['invokable'] = new Invokable();
+
+        $this->assertInstanceOf('Pimple\Tests\Service', $pimple['invokable']);
+    }
+
+    /** @test */
+    public function settingNonInvokableObjectShouldTreatItAsParameter()
+    {
+        $pimple = new Pimple();
+        $pimple['non_invokable'] = new NonInvokable();
+
+        $this->assertInstanceOf('Pimple\Tests\NonInvokable', $pimple['non_invokable']);
+    }
+
+    /**
+     * @dataProvider badServiceDefinitionProvider
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Service definition is not a Closure or invokable object.
+     */
+    public function testShareFailsForInvalidServiceDefinitions($service)
+    {
+        $pimple = new Pimple();
+        $pimple->share($service);
+    }
+
+    /**
+     * @dataProvider badServiceDefinitionProvider
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Callable is not a Closure or invokable object.
+     */
+    public function testProtectFailsForInvalidServiceDefinitions($service)
+    {
+        $pimple = new Pimple();
+        $pimple->protect($service);
+    }
+
+    /**
+     * @dataProvider badServiceDefinitionProvider
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Identifier "foo" does not contain an object definition.
+     */
+    public function testExtendFailsForKeysNotContainingServiceDefinitions($service)
+    {
+        $pimple = new Pimple();
+        $pimple['foo'] = $service;
+        $pimple->extend('foo', function () {});
+    }
+
+    /**
+     * @dataProvider badServiceDefinitionProvider
+     * @expectedException InvalidArgumentException
+     * @expectedExceptionMessage Extension service definition is not a Closure or invokable object.
+     */
+    public function testExtendFailsForInvalidServiceDefinitions($service)
+    {
+        $pimple = new Pimple();
+        $pimple['foo'] = function () {};
+        $pimple->extend('foo', $service);
+    }
+
+    /**
+     * Provider for invalid service definitions
+     */
+    public function badServiceDefinitionProvider()
+    {
+        return array(
+          array(123),
+          array(new NonInvokable())
+        );
+    }
+
+    /**
+     * Provider for service definitions
+     */
+    public function serviceDefinitionProvider()
+    {
+        return array(
+            array(function ($value) {
+                $service = new Service();
+                $service->value = $value;
+
+                return $service;
+            }),
+            array(new Invokable())
+        );
+    }
+}

vendor/pimple/pimple/tests/Pimple/Tests/Service.php

@@ -0,0 +1,37 @@
+<?php
+
+/*
+ * This file is part of Pimple.
+ *
+ * Copyright (c) 2009 Fabien Potencier
+ *
+ * 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.
+ */
+
+namespace Pimple\Tests;
+
+/**
+ * Pimple Test Service
+ *
+ * @package pimple
+ * @author  Igor Wiedler <igor@wiedler.ch>
+ */
+class Service
+{
+}

vendor/pimple/pimple/tests/bootstrap.php

@@ -0,0 +1,15 @@
+<?php
+
+/*
+ * This file is part of the Silex framework.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+require_once __DIR__.'/../lib/Pimple.php';
+require_once __DIR__.'/Pimple/Tests/Service.php';
+require_once __DIR__.'/Pimple/Tests/Invokable.php';
+require_once __DIR__.'/Pimple/Tests/NonInvokable.php';