PHP IoC::instance方法代码示例

 private static function setup()
 {
     // Query metadata and store into our config
     $sql = "select `key`, `value` from meta";
     Config::set('metadata', Db::pairs($sql));
     // look up which page has our posts
     $page = Pages::find(array('id' => Config::get('metadata.posts_page')));
     IoC::instance('posts_page', $page, true);
 }

function search_results()
{
    $posts = IoC::resolve('search');
    if ($result = $posts->valid()) {
        // register single post
        IoC::instance('article', $posts->current(), true);
        // move to next
        $posts->next();
    }
    return $result;
}

 private static function setup()
 {
     // Query metadata and store into our config
     $sql = "select `key`, `value` from meta";
     $meta = array();
     foreach (Db::results($sql) as $row) {
         $meta[$row->key] = $row->value;
     }
     Config::set('metadata', $meta);
     // look up which page has our posts
     $page = Pages::find(array('id' => Config::get('metadata.posts_page')));
     IoC::instance('posts_page', $page, true);
 }

function posts()
{
    if (has_posts() === false) {
        return false;
    }
    $posts = IoC::resolve('posts');
    if ($result = $posts->valid()) {
        // register single post
        IoC::instance('article', $posts->current(), true);
        // move to next
        $posts->next();
    }
    return $result;
}

function comments()
{
    if (has_comments() === false) {
        return false;
    }
    $items = IoC::resolve('comments');
    if ($result = $items->valid()) {
        // register single comment
        IoC::instance('comment', $items->current(), true);
        // move to next
        $items->next();
    }
    return $result;
}

 public function search($term = '')
 {
     if (Input::method() == 'POST') {
         if (Input::post('term') !== false) {
             return Response::redirect('search/' . rawurlencode(Input::post('term')));
         }
     }
     $search = Posts::search($term, array('status' => 'published'));
     IoC::instance('search', $search, true);
     $page = new StdClass();
     $page->title = 'Search';
     IoC::instance('page', $page, true);
     Template::render('search');
 }

 public function search($term = '')
 {
     if (Input::method() == 'POST') {
         if (Input::post('term') !== false) {
             return Response::redirect('search/' . rawurlencode(Input::post('term')));
         }
     }
     $search = Posts::search($term, array('status' => 'published', 'limit' => Config::get('metadata.posts_per_page', 10), 'offset' => Input::get('offset', 0)));
     IoC::instance('search', $search, true);
     $total = Posts::search_count($term, array('status' => 'published'));
     IoC::instance('total_search', $total, true);
     $page = new StdClass();
     $page->id = -1;
     $page->title = 'Search';
     IoC::instance('page', $page, true);
     Template::render('search');
 }

function menu_items($params = array())
{
    if (!has_menu_items()) {
        return false;
    }
    if (($pages = IoC::resolve('menu')) === false) {
        $params['status'] = 'published';
        $pages = Pages::list_all($params);
        IoC::instance('menu', $pages, true);
    }
    if ($result = $pages->valid()) {
        // register single post
        IoC::instance('menu_item', $pages->current(), true);
        // move to next
        $pages->next();
    }
    return $result;
}

 private function doRequest($URI, $data = [])
 {
     Input::$input = $data;
     Laravel\Routing\Filter::register(require APP_PATH . 'filters' . EXT);
     $loader = new Laravel\Routing\Loader(APP_PATH, ROUTE_PATH);
     $router = new Laravel\Routing\Router($loader, CONTROLLER_PATH);
     IoC::instance('laravel.routing.router', $router);
     Laravel\Request::$route = $router->route(Laravel\Request::method(), Laravel\URI::current());
     if (!is_null(Request::$route)) {
         $response = Request::$route->call();
     } else {
         Laravel\Routing\Filter::run(['before'], [], true);
         $response = Laravel\Response::json(['msg' => 'Not found'], 404);
         \Laravel\Routing\Filter::run(['after'], [$response], true);
     }
     ob_start();
     $response->send();
     $output = ob_get_contents();
     ob_end_clean();
     return $output;
 }

 */
unset($input[Request::spoofer]);
Input::$input = $input;
//Compatibility hack
set_log4php_env('ls_log_file', \Config::get('env.log_path') . '/content.log');
\Logger::configure(\Config::get('log4php'));
/**
 * Route the request to the proper route in the application. If a
 * route is found, the route will be called with the current request
 * instance. If no route is found, the 404 response will be returned
 * to the browser.
 */
Routing\Filter::register(require APP_PATH . 'filters' . EXT);
$loader = new Routing\Loader(APP_PATH, ROUTE_PATH);
$router = new Routing\Router($loader, CONTROLLER_PATH);
IoC::instance('laravel.routing.router', $router);
Request::$route = $router->route(Request::method(), URI::current());
if (!is_null(Request::$route)) {
    $new_relic->name_transaction(Request::$route->key);
    try {
        $response = Request::$route->call();
    } catch (\Exception $e) {
        $handler($e);
    }
} else {
    $new_relic->name_transaction('404');
    \Laravel\Routing\Filter::run(array('before'), array(), true);
    $response = \Response::json(['msg' => 'Not found'], 404);
    \Laravel\Routing\Filter::run(array('after'), array($response), true);
}
$response->send();

 */
if (magic_quotes()) {
    $magics = array(&$_GET, &$_POST, &$_COOKIE, &$_REQUEST);
    foreach ($magics as &$magic) {
        $magic = array_strip_slashes($magic);
    }
}
/**
 * Load the session using the session manager. The payload will
 * be registered in the IoC container as an instance so it can
 * be easily access throughout the framework.
 */
if (Config::get('session.driver') !== '') {
    Session::start(Config::get('session.driver'));
    Session::load(Cookie::get(Config::get('session.cookie')));
    IoC::instance('laravel.session', Session::$instance);
}
/**
 * Gather the input to the application based on the global input
 * variables for the current request. The input will be gathered
 * based on the current request method and will be set on the
 * Input manager class' static $input property.
 */
$input = array();
switch (Request::method()) {
    case 'GET':
        $input = $_GET;
        break;
    case 'POST':
        $input = $_POST;
        break;

    spl_autoload_register(function ($class) {
        if (substr($class, 0, 7) === 'Dropbox') {
            $class = str_replace('\\', '/', $class);
            require_once __DIR__ . '/' . $class . '.php';
        }
    });
    $app_key = Laravel\Config::get('dropbox::config.app_key');
    $app_secret = Laravel\Config::get('dropbox::config.app_secret');
    $encryption_key = Laravel\Config::get('dropbox::config.encryption_key');
    if (empty($app_key) || empty($app_secret)) {
        throw new \Dropbox\Exception('Please set your Dropbox App key & secret.');
    }
    if (strlen($encryption_key) !== 32) {
        throw new \Dropbox\Exception('Expecting a 32 byte Dropbox encryption key, got ' . strlen($encryption_key));
    }
    // Check whether to use HTTPS and set the callback URL
    $protocol = isset($_SERVER['HTTPS']) && !empty($_SERVER['HTTPS']) ? 'https' : 'http';
    $request_uri = isset($_SERVER['REQUEST_URI']) ? $_SERVER['REQUEST_URI'] : '/';
    $http_host = isset($_SERVER['HTTP_HOST']) ? $_SERVER['HTTP_HOST'] : '127.0.0.1';
    $callback = $protocol . '://' . $http_host . $request_uri;
    // Instantiate the required Dropbox objects
    $encrypter = new \Dropbox\OAuth\Storage\Encrypter($encryption_key);
    $storage = new \Dropbox\OAuth\Storage\Session($encrypter);
    if ($access_token = Config::get('dropbox::config.access_token')) {
        $storage->set((object) $access_token, 'access_token');
    }
    $OAuth = new \Dropbox\OAuth\Consumer\Curl($app_key, $app_secret, $storage, $callback);
    $dropbox = new \Dropbox\API($OAuth, Laravel\Config::get('dropbox::config.root'));
    IoC::instance('dropbox::session', $storage);
    IoC::instance('dropbox::api', $dropbox);
});

 /**
  * Test the IoC::instance method.
  *
  * @group laravel
  */
 public function testInstancesAreReturnedBySingleton()
 {
     $object = new StdClass();
     IoC::instance('bar', $object);
     $this->assertTrue($object === IoC::resolve('bar'));
 }

| Register PSR-0 Autoloading
|--------------------------------------------------------------------------
|
| Basset uses PSR-0 autoloading to lazily load the required files when
| requested. Here we'll provide the namespaces and their corrosponding
| locations.
|
*/
Autoloader::namespaces(array('Assetic' => __DIR__ . '/vendor/assetic/src/Assetic', 'Basset' => __DIR__ . '/classes'));
/*
|--------------------------------------------------------------------------
| Basset Facade Alias
|--------------------------------------------------------------------------
|
| Alias Basset to the Basset Facade so that we can use a terser static
| syntax to access methods. Lovely.
|
*/
Autoloader::alias('Basset\\Facades\\Basset', 'Basset');
/*
|--------------------------------------------------------------------------
| Register Basset with the IoC
|--------------------------------------------------------------------------
|
| Basset is registered within the IoC container so that everything is
| somewhat testable. We'll use a facade to provide a terser static
| interface.
|
*/
IoC::instance('basset', new Basset\Basset());

 public function testTextMatchingCaseSensitive()
 {
     // stub out the request class
     $mock = Mockery::mock('ClementiaRequest');
     $test_result = new stdClass();
     $test_result->status_code = 200;
     $test_result->body = '<html><body><h1 class="active hover">Some Text</h1></body></html>';
     $mock->shouldReceive('get')->andReturn($test_result);
     // set the requests object to be our stub
     IoC::instance('requests', $mock);
     $tester = IoC::resolve('tester');
     $result = $tester->test('text', 'http://dhwebco.com', array('text' => 'Some Text', 'case_sensitive' => TRUE));
     $this->assertTrue($result);
 }