filp/gimme

dev-master 2013-08-10 13:17 UTC

This package is not auto-updated.

Last update: 2022-01-16 23:24:49 UTC


README

Inject your services with magic.

A super-simple library to auto-magically inject named services from a $services* argument. Services come from service providers, that can be introduced to Gimme through a simple stack layout.

* Or not, have a look at Gimme\Resolver::setArgumentName

<?php

use Gimme\Resolver;
use Pimple;
use Foo;

// Create a service provider, for this example, using Pimple:
$pimple = new Pimple;
$pimple['myService'] = function() {
    return new Foo;
};

// Introduce the provider to Gimme, wrapping it in a closure
// that knows how to talk to Pimple:
$resolver = new Resolver;
$resolver->pushProvider(
    function($serviceName) use($pimple) { return $pimple[$serviceName]; };
);

// Use it. Tell Gimme that this callable (which can be a closure, a function
// or a method) wants to use a service called 'myService', which one of the
// registered service providers will be able to fetch for you.
$resolver->call(function($services = array('myService')) {
    var_dump($services->myService); #=> instance of Foo
});

Features:

  • Light-weight, tested code-base.

  • Hands-off service injection through the $services argument

  • Stupid-simple to implement support for any type of service provider

  • Your callable/method's arguments are preserved, so it's a great fit with those modern space-age frameworks

    // warning: example may not make much sense
    $app->get('/user/{id}', $resolver->bind(function($id, $services = array('user') {
        return $services->user->get($id);
    }));
  • Service providers may be a simple closure:

    $resolver->pushProvider(function($serviceName) {
        if($serviceName == 'bananas') {
            return 'Here, have some bananas!';
        }
    });
  • Support for callable-binding (bind your callable to the method injector, call it whenever).

    $bound = $resolver->bind(function($services = array('someService')) {
        return $services->someService->doThings();
    });
    
    // Give the bound method to your killer router of sorts:
    $app->get('/foo', $bound);
  • Support for service-name aliases:

    $resolver->alias('bananaService', 'turnipService');
    $resolver->call(function($services = array('bananaService')) {
        print "I love {$services->bananaService->name()}!"; #=> I love turnip!
    });

Should I use this?

Dunno. It was fun to work on, but I'm not going to be the one to tell you to use it. The code is solid, if there's a point in using it for your needs, it's a point for you to make.

Install it:

Use Composer, add the following to your composer.json:

{
    "require": {
        "filp/gimme": "dev-master"
    }
}

And then:

$ composer install