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;
/**
* 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);
}
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);
});
