statical/slim-static

Static proxy implementation for Slim framework

SlimStatic

, _(*1)

Slim PHP static proxy library., _(*2)

Contents

• About
• Usage
• API
• Customizing
• License

, _(*3)

About

SlimStatic provides a simple static interface to various features in the Slim micro framework. Turn this:, _(*4)

$app->get('/hello-world', function()
{
    $app = Slim::getInstance();

    $app->view()->display('hello.html', array(
        'name' => $app->request()->get('name', 'world')
    ));
});

$app->run();

into this:, _(*5)

Route::get('/hello-world', function()
{
    View::display('hello.html', array(
        'name' => Input::get('name', 'world')
    ));
});

App::run();

This library is based on Slim-Facades from Miroslav Rigler, but uses Statical to provide the static proxy interface., _(*6)

, _(*7)

Usage

Install via composer, _(*8)

composer require statical/slim-static

Create your Slim app and boot SlimStatic:, _(*9)

use Slim\Slim;
use Statical\SlimStatic\SlimStatic;

$app = new Slim();

SlimStatic::boot($app);

Now you can start using the static proxies listed below. In addition there is a proxy to Statical itself, aliased as Statical and available in any namespace, so you can easily use the library to add your own proxies (see Customizing) or define namespaces., _(*10)

If your app is namespaced you can avoid syntax like \App::method or use statements by employing the namespacing feature:, _(*11)

# Allow any registered proxy to be called anywhere in the `App\Name` namespace

Statical::addNamespace('*', 'App\\Name\\*');

, _(*12)

API

The following static proxies are available:, _(*13)

, _(*14)

App

Proxy to the Slim instance. Note that you cannot use the built-in resource locator statically, because App::foo = 'bar' is not a method call. Use the Container proxy instead., _(*15)

App::expires('+1 week');
App::halt();

, _(*16)

Config

Sugar for Slim config, using the following methods:, _(*17)

• get($key) - returns value of $app->config($key)
• set($key, $value = null) - calls $app->config($key, $value)

$debug = Config::get('debug');
Config::set('log.enable', true);

# Note that you could also use:
$debug = App::config('debug');
App::config('log.enable', true);

, _(*18)

Container

Proxy to the Slim container instance. Use this to access the built-in resource locator., _(*19)

# $app->foo = 'bar'
Container::set('foo', 'bar');

# $bar = $app->foo
$bar = Container::get('foo');

Container::singleton('log', function () {...});
$rawClosure = Container::protect(function () {...});

, _(*20)

Input

Proxy to the Slim\Http\Request instance with an additional method:, _(*21)

• file($name) - returns $_FILES[$name], or null if the file was not sent in the request

$avatar = Input::file('avatar');
$username = Input::get('username', 'default');
$password = Input::post('password');

, _(*22)

Log

Proxy to the Slim\Log instance., _(*23)

Log::info('My info');
Log::debug('Degug info');

, _(*24)

Request

Proxy to the Slim\Http\Request instance., _(*25)

$path = Request::getPath();
$xhr = Request::isAjax();

, _(*26)

Response

Proxy to the Slim\Http\Response instance., _(*27)

Response::redirect('/success');
Response::headers->set('Content-Type', 'application/json');

, _(*28)

Route

Sugar for the following Slim instance route-mapping methods:, _(*29)

• map, get, post, put, patch, delete, options, group, any, urlFor

Route::get('/users/:id', function ($id) {...});
Route::post('/users',  function () {...});
Route::urlFor('admin');

Note that because these methods call the Slim instance you can also invoke them with App::get, App::post etc., _(*30)

, _(*31)

View

Proxy to the Slim\View instance, _(*32)

View::display('hello.html');
$output = View::render('world.html');

, _(*33)

Customizing

Since Statical is already loaded, you can use it to create your own static proxies. Let's take a PaymentService class as an example, that you want to alias as Payment., _(*34)

The first step is to create a proxy class that extends the Statical\BaseProxy class. It is normally empty and you can name it whatever you wish:, _(*35)

class PaymentProxy extends \Statical\BaseProxy {}

You must then register this with Statical, using addProxyInstance if you use a class instance, or addProxyService if you want to use the Slim container. Using a class instance:, _(*36)

# create our PaymentService class
$instance = new \PaymentService();

$alias = 'Payment';             # The static alias to call
$proxy = 'PaymentProxy';        # The proxy class you just created

Statical::addProxyInstance($alias, $proxy, $instance);

# Now we can call PaymentService methods via the static alias Payment
Payment::process();

Using the Slim container:, _(*37)

# Register our service with Slim's DI container
Container::set('payment', function () {
    return new \PaymentService();
});


$alias = 'Payment';             # The static alias to call
$proxy = 'PaymentProxy';        # The proxy class you just created
$id = 'payment';                # The id of our service in the Slim container

Statical::addProxyService($alias, $proxy, Container::getInstance(), $id);

# Now we can call PaymentService methods via the static alias Payment
Payment::process();

Note that for namespaced code, the namespace must be included in the $proxy param., _(*38)

, _(*39)

License

SlimStatic is licensed under the MIT License - see the LICENSE file for details, _(*40)