function u($short_url)
{
$args = func_get_args();
$route_info = Nimble::getInstance()->get_route_info_by_short_name($short_url);
$args = array_merge(array($route_info->controller, $route_info->method), array_slice($args, 1));
return call_user_func_array('UrlBuilder::url_for', $args);
}
/**
* Get the global Nimble object instance.
* @return Nimble The global Nimble reference.
*/
public static function getInstance()
{
if (self::$instance == NULL) {
self::$instance = new Nimble();
}
return self::$instance;
}
/**
* This handles uploads to a persions channel
* Need file posted as 'file' and the has poster as 'hash'
*/
public function upload()
{
switch ($this->format) {
case 'xml':
try {
$package = Package::from_upload(array('file' => $_FILES['file']['tmp_name'], 'sig' => $_POST['signatureBase64'], 'user' => $this->user), true);
if ($package->saved) {
echo 'Package uploaded succesfuly!';
}
} catch (Exception $e) {
$this->header("HTTP/1.0 500 Internal Server Error", 500);
echo $e->getMessage();
}
$this->has_rendered = true;
break;
default:
if ($_SESSION['upload_key'] !== $_POST['upload_key']) {
Nimble::flash('notice', 'Invalid Upload Key');
$this->redirect_to(url_for('LandingController', 'user_index', $this->user->username));
}
unset($_SESSION['upload_key']);
try {
$package = Package::from_upload(array('file' => $_FILES['file']['tmp_name'], 'user' => $this->user));
if ($package->saved) {
$this->redirect_to(url_for('LandingController', 'user_index', $this->user->username));
}
} catch (Exception $e) {
Nimble::flash('notice', $e->getMessage());
$this->redirect_to(url_for('ChannelController', 'upload'));
}
break;
}
}
public function show_flash()
{
if (isset($_SESSION['flashes']['notice']) && !empty($_SESSION['flashes']['notice'])) {
$notice = Nimble::display_flash('notice');
echo "<div id='flash' class='notice'>{$notice}</div>";
}
}
public function testPageTitleCarrierWithCustomSeperator()
{
Nimble::set_config('site_title', 'Mysite');
Nimble::set_config('title_seperator', '->');
Nimble::set_title('My Page');
$this->assertEquals('Mysite->My Page', Nimble::get_title());
}
public static function build($rootNode, $vals = null)
{
$xsz = new XML_Serializer(array('rootName' => $rootNode, 'mode' => 'simplexml'));
$xsz->serialize($vals);
$xml = $xsz->getSerializedData();
Nimble::log($xml, PEAR_LOG_DEBUG);
return $xml;
}
function Run($test_mode = false)
{
if (defined('NIMBLE_IS_TESTING')) {
$test_mode = NIMBLE_IS_TESTING;
}
Nimble::getInstance()->dispatch($test_mode);
// exceptions handled by my_exception_handler.
}
/**
* @expectedException NimbleException
*/
public function testUrlForFailsWrongParams()
{
$this->Nimble->routes = array();
$this->Nimble->uri = '';
Nimble::set_config('url', '/class/1');
$this->Nimble->add_url('/class/:method', "Class", "Method");
$this->assertEquals('/class/1', url_for('Class', 'Method', 1, 2));
}
/**
* Bind the Route object to Nimble's router.
* @throws NimbleException if the requested HTTP method is invalid.
*/
function bind()
{
if (in_array($this->http_method, self::$allowed_methods)) {
$router = Nimble::getInstance()->add_url($this->pattern, $this->controller, $this->action, $this->http_method);
} else {
throw new NimbleException('Invalid Request');
}
}
public function testLoadBothCustomAndNimble()
{
Nimble::plugins('test_plugin');
$this->Nimble->__construct();
$this->Nimble->dispatch(true);
$test_class = new TestPlugin();
$this->assertEquals($test_class->foo(), 'foo');
$this->assertEquals(1, 1);
}
function __construct()
{
$this->nimble = Nimble::getInstance();
$this->view_path = $this->nimble->config['view_path'];
if (defined('NIMBLE_IS_TESTING') && NIMBLE_IS_TESTING && defined('FAKEMAIL_PORT')) {
$this->mailmethod = 'smtp';
$this->mailparams['port'] = FAKEMAIL_PORT;
}
}
public function testGETisSetFromUrlArgs()
{
global $_GET;
Nimble::set_config('url', '/class/1');
$this->Nimble->add_url('/class/:method', "MyTestClass", "method");
$this->Nimble->dispatch(true);
$this->assertTrue(isset($_GET['method']));
$this->assertEquals($_GET['method'], '1');
}
/**
* This class has 3 required variables that need to be set
* $from (string), $subject (string), $recipient | $recipients (string || array)
* Options Variables
* $time (time), $headers (string)
*/
public function __construct()
{
$this->nimble = Nimble::getInstance();
$this->view_path = $this->nimble->config['view_path'];
$this->class = get_called_class();
$this->time = time();
$this->_divider = '------=_' . rand(10000000, 99999999999) * 2;
$this->_content = array();
}
public function index()
{
$this->title = 'Making it trivially easy to create PEAR packages.';
Nimble::set_title($this->title);
$this->set_default_side_bar();
if ($this->is_logged_in()) {
$this->login_user();
}
}
public function setUp()
{
$_SESSION = array();
$_POST['_method'] = 'GET';
$_SERVER['REQUEST_METHOD'] = '';
$_SESSION['flashes'] = array();
$this->Nimble = Nimble::getInstance();
$this->Nimble->routes = array();
$this->Nimble->url = '';
}
public function setUp()
{
$_SESSION = array();
$_SESSION['flashes'] = array();
$_SERVER['REQUEST_METHOD'] = 'GET';
$this->Nimble = Nimble::getInstance();
$this->Nimble->routes = array();
$this->url = '';
$this->Nimble->test_mode = true;
Nimble::set_config('plugins_path', join(DIRECTORY_SEPARATOR, array(dirname(__FILE__), 'test_plugins')));
Nimble::set_config('view_path', join(DIRECTORY_SEPARATOR, array(dirname(__FILE__), 'views')));
}
public function delete()
{
$this->login_user();
try {
$package = Package::find('first', array('conditions' => array('id' => $_GET['id'], 'user_id' => $this->user->id)));
$package->clear_all_version();
Nimble::flash('notice', $package->name . " was deleted");
$package->destroy();
$this->redirect_to('/');
} catch (NimbleRecordNotFound $e) {
Nimble::flash('notice', "Package does not exist or does not belong to you");
$this->redirect_to('/');
}
}
function Run($test_mode = false)
{
try {
Nimble::getInstance()->dispatch($test_mode);
} catch (Exception $e) {
if (NIMBLE_ENV == 'development' && !$test_mode) {
?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<title>Error!</title>
</head>
<body>
<h1>Caught exception: <?php
echo $e->getMessage();
?>
</h1>
<h2>File: <?php
echo $e->getFile();
?>
</h2>
<h2>Line: <?php
echo $e->getLine();
?>
</h2>
<h3>Trace</h3>
<pre>
<?php
echo $e->getTraceAsString();
?>
</pre>
<h3>Exception Object</h3>
<pre>
<?php
var_dump($e);
?>
</pre>
<h3>Var Dump</h3>
<pre>
<?php
debug_print_backtrace();
?>
</pre>
</body>
</html>
<?php
}
}
}
public function delete()
{
$this->login_user();
try {
$package = Package::find($_GET['id']);
$version = Version::find($_GET['version']);
} catch (NimbleRecordNotFound $e) {
$this->redirect_to('/');
}
if ($version->package_id == $package->id && $package->user_id == $this->user->id) {
$file = $package->file_path($version->version);
@unlink($file);
Nimble::flash('notice', "Version: {$version->version} was deleted");
$version->delete();
$this->redirect_to(url_for('PackageController', 'show', $package->user->username, $package->name));
} else {
$this->redirect_to('/');
}
}
/**
* @param string $action action you wish to call
* @param array $action_params array of arguments to pass to the action method
*/
private function load_action($action, $action_params)
{
global $_SESSION, $_POST, $_GET;
$nimble = Nimble::getInstance();
ob_start();
$controller = new $this->controller_name();
$controller->format = !empty($action_params['format']) ? $action_params['format'] : $controller->default_format;
call_user_func(array($controller, "run_before_filters"), $action);
call_user_func_array(array($controller, $action), array($action_params));
$path = strtolower(Inflector::underscore(str_replace('Controller', '', $this->controller_name)));
$template = FileUtils::join($path, $action);
if ($controller->has_rendered === false) {
if (empty($controller->layout_template) && $controller->layout) {
$controller->set_layout_template();
}
$controller->render($template);
}
call_user_func(array($controller, "run_after_filters"), $action);
$this->response = ob_get_clean();
$this->controller = $controller;
}
}
/** load nimble */
require_once 'nimblize/nimblize.php';
/** Set the path to the view templates */
Nimble::set_config('view_path', FileUtils::join(dirname(__FILE__), '..', 'app', 'view'));
/** set the default plugin path */
Nimble::set_config('plugins_path', FileUtils::join(dirname(__FILE__), '..', 'plugin'));
Nimble::set_config('default_layout', FileUtils::join(Nimble::getInstance()->config['view_path'], 'layout', 'application.php'));
/** set asset path change this in your config.php to override */
Nimble::set_config('stylesheet_folder', FileUtils::join(dirname(__FILE__), '..', 'public', 'style'));
Nimble::set_config('stylesheet_folder_url', '/public/style');
Nimble::set_config('javascript_folder', FileUtils::join(dirname(__FILE__), '..', 'public', 'javascript'));
Nimble::set_config('javascript_folder_url', '/public/javascript');
Nimble::set_config('image_url', 'public/image');
Nimble::set_config('image_path', FileUtils::join(dirname(__FILE__), '..', 'public', 'image'));
Nimble::set_config('uri', '/');
//define the root
define('NIMBLE_ROOT', FileUtils::join(dirname(__FILE__), '..'));
// load any custom global config options
require_once FileUtils::join(dirname(__FILE__), 'config.php');
require_once FileUtils::join(dirname(__FILE__), 'routes.php');
require_once FileUtils::join(dirname(__FILE__), 'r404.php');
// load any custom enviroment config options
// Nimble::Log('loading ' . NIMBLE_ENV . ' enviroment');
require_once FileUtils::join(dirname(__FILE__), NIMBLE_ENV, 'config.php');
require_once FileUtils::join(NIMBLE_ROOT, 'app', 'controller', 'application_controller.php');
/** load controlers and models */
foreach (array('model', 'controller') as $dir) {
__load_files(FileUtils::join(dirname(__FILE__), '..', 'app', $dir));
}
session_set_cookie_params(time() + 1000, '/', '.' . DOMAIN);
/**
* Match the HTTP request's URL and HTTP method against the stored routes and, if a match is found, call the appropriate controller's method.
* If the client you're using doesn't support sending HTTP requests with methods
* other than GET or POST, set $_POST['_method'] to the actual HTTP method you wish to use.
*/
public function dispatch($test = false)
{
$this->load_plugins();
foreach ($this->routes as $rule => $conf) {
// if a vaild _method is passed in a post set it to the REQUEST_METHOD so that we can route for DELETE and PUT methods
if (isset($_POST['_method']) && !empty($_POST['_method']) && in_array(strtoupper($_POST['_method']), Route::$allowed_methods)) {
$_SERVER['REQUEST_METHOD'] = strtoupper($_POST['_method']);
}
if (empty($_SERVER['REQUEST_METHOD'])) {
if (!$test) {
throw new NimbleException('No valid Request Method given.');
} else {
return false;
}
}
/** test to see if its a valid route */
if (preg_match($conf[0], $this->url, $matches) && (empty($conf[3]) || $_SERVER['REQUEST_METHOD'] == $conf[3])) {
/** Only declared variables in URL regex */
$matches = $this->parse_urls_args($matches);
$this->klass = new $conf[1]();
/** set the layout tempalte to the default */
$this->klass->set_layout_template();
$this->klass->format = $conf[4] ? array_pop($matches) : $this->klass->default_format;
Nimble::log("dispatching '/{$this->url}' as {$conf[1]}::{$conf[2]} {$conf[3]} {$this->klass->format}", NIMBLE_LOG_INFO);
ob_start();
// call before filters
call_user_func(array($this->klass, "run_before_filters"), $conf[2]);
// call methods on controller class
call_user_func_array(array($this->klass, $conf[2]), array($matches));
if (!$this->klass->has_rendered && isset($this->config['view_path'])) {
$dir = str_replace('Controller', '', $conf[1]);
$dir = strtolower(Inflector::underscore($dir));
$tpl = empty($this->klass->template) ? $conf[2] : $this->klass->template;
$view = FileUtils::join($dir, $tpl);
$this->klass->render($view);
}
// call after filters
call_user_func(array($this->klass, "run_after_filters"), $conf[2]);
$out = ob_get_clean();
if (count($this->klass->headers) > 0) {
foreach (array_values($this->klass->headers) as $header) {
if (!$this->test_mode) {
header($header[0], true, empty($header[1]) ? null : $header[1]);
}
}
}
print $out;
if (!$test) {
exit;
}
}
}
if (!$test) {
if (class_exists('r404')) {
if (method_exists('r404', $_SERVER['REQUEST_METHOD'])) {
call_user_func(array('r404', $_SERVER['REQUEST_METHOD']));
} else {
call_user_func(array('r404', 'renderError'));
}
} else {
throw new NimbleException("Routing Error. No suitable routes found and no 404 handler exists.");
}
}
}
function rebind()
{
if (isset($this->bind_id)) {
Nimble::getInstance()->remove_url_by_id($this->bind_id);
$this->bind();
}
}
/**
* respond to a given request format directly, using a specific function/method
* - instead of the default Controller->render() action which loads a view.
*
* Would be nice to use a lambda function with a closure here, so we could pass the controller
* itself to the function at runtime. But for php<5.3 have to settle for this.
*
* example call, in a controller action:
* $this->respond_to('xml', array('XMLview', 'build'), array('loginResult', $this->result));
* # pre-supposes that xml_view plugin is loaded via Nimble::plugins('xml_view')
*
* @param $format string format we are expecting to respond to (xml, json, etc)
* @param $func mixed function name, reference or array suitable for call_user_func_array()
* @param $args array opt arguments to be passed to the function
* @throws NimbleException
*/
public function respond_to($format, $func = null, $args = array())
{
if ($this->format() == $format) {
if (is_callable($func)) {
$funcname = is_array($func) ? $func[0] . '::' . $func[1] : (string) $funcname;
Nimble::log("responding to {$format} with {$funcname}", NIMBLE_LOG_DEBUG);
echo call_user_func_array($func, $args);
$this->has_rendered = true;
if (isset($this->headers_by_format[$format])) {
$this->headers[] = $this->headers_by_format[$format];
}
} else {
throw new NimbleException('Uncallable function given to respond_to()');
}
}
}
public function setUp()
{
$this->nimble = Nimble::getInstance();
$this->nimble->config['view_path'] = join(DIRECTORY_SEPARATOR, array(dirname(__FILE__), 'views'));
}
/**
* Include a PHP file, inject the controller's properties into that file, and return the output.
* @param string $file The view file to render, relative to the base of the application.
* @return string The rendered view file.
*/
public function render_partial($file)
{
NimbleLogger::log("RENDERING PARTIAL: {$file}");
$this->rendered_partials[] = $file;
return $this->open_template(FileUtils::join(Nimble::getInstance()->config['view_path'], $file));
}
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
<link rel="Shortcut Icon" href="/public/image/favico.ico" />
<link rel="icon" href="/public/image/favico.ico" type="image/x-icon" />
<link rel="search" type="application/opensearchdescription+xml" href="http://<?php
echo DOMAIN;
?>
/opensearch.xml" title="Pearfarm" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<meta name="google-site-verification" content="griVQ0kTz8ri_7TzrEN8bOALKwWT8g2fgbow_3GsDQM" />
<meta name="description" content="Pearfarm is the Php community's pear hosting service. Instantly publish your pear packages and install them. Become a contributor and enhance the site with your own changes." />
<meta name="keywords" content="php pear packages community code repository opensource" />
<title><?php
echo h(Nimble::get_title());
?>
</title>
<?php
echo stylesheet_link_tag('stylesheet.css', 'facebox.css');
?>
<!--[if lt IE 7]>
<?php
echo javascript_include_tag('pngfix.js');
?>
<![endif]-->
<?php
echo javascript_include_tag('prototype.js', 'scriptaculous.js', 'facebox.js');
?>
<script type='text/javascript'>
Event.observe(window, 'load', function(){
/**
* Dump out application routes to a human readable format.
* @param boolean $cli True if being called from the command line.
* @return string The application's routes in a human readable format.
*/
public static function dumpRoutes($cli = false)
{
$klass = Nimble::getInstance();
$out = array();
foreach ($klass->routes as $route) {
$pattern = self::clean_route($route[0]);
$pattern = empty($pattern) ? 'root path' : $pattern;
array_push($out, "Controller: {$route[1]} Action: {$route[2]} Method: {$route[3]} Pattern: " . $pattern);
}
$return = "\n";
$return .= join("\n", $out);
$return .= "\n";
return $cli ? $return : htmlspecialchars($return);
}
public function stats()
{
$this->title = 'Pearfarm Stats';
Nimble::set_title($this->title);
}
/**
* Include a PHP file, inject the controller's properties into that file, and return the output.
* @param string $file The view file to render, relative to the base of the application.
* @return string The rendered view file.
*/
public function render_partial($file)
{
$this->rendered_partials[] = $file;
return $this->open_template(FileUtils::join(Nimble::getInstance()->config['view_path'], $file));
}
