public static function init() { $url = $_SERVER['REQUEST_URI']; $isCustom = false; if (count(self::$rules)) { foreach (self::$rules as $ruleKey => $ruleData) { $params = self::ruleMatch($ruleKey, $url); if ($params) { self::$controller = $ruleData['controller']; self::$action = $ruleData['action']; self::$params = $params; $isCustom = true; break; } } } if (!$isCustom) { self::defaultRoutes($url); } if (!strlen(self::$controller)) { self::$controller = 'site'; } if (!strlen(self::$action)) { self::$action = ''; } if (self::$action == ':site') { self::$action = self::getParam("site"); } }
static function parse_url() { if (Router::$controller) { return; } // Work around problems with the CGI sapi by enforcing our default path if ($_SERVER["SCRIPT_NAME"] && "/" . Router::$current_uri == $_SERVER["SCRIPT_NAME"]) { Router::$controller_path = MODPATH . "gallery/controllers/albums.php"; Router::$controller = "albums"; Router::$method = 1; return; } $current_uri = html_entity_decode(Router::$current_uri, ENT_QUOTES); $item = ORM::factory("item")->where("relative_path_cache", $current_uri)->find(); if (!$item->loaded) { // It's possible that the relative path cache for the item we're looking for is out of date, // so find it the hard way. $count = count(Router::$segments); foreach (ORM::factory("item")->where("name", html_entity_decode(Router::$segments[$count - 1], ENT_QUOTES))->where("level", $count + 1)->find_all() as $match) { if ($match->relative_path() == $current_uri) { $item = $match; } } } if ($item && $item->loaded) { Router::$controller = "{$item->type}s"; Router::$controller_path = MODPATH . "gallery/controllers/{$item->type}s.php"; Router::$method = $item->id; } }
/** * @param $url * @throws Exception */ public static function parse($url) { $arr = explode('?', $url); $url = rtrim($arr[0], '/'); if (!$url) { self::$controller = 'IndexController'; self::$action = 'indexAction'; return; } foreach (self::$routes as $route => $item) { $regex = $item['pattern']; foreach ($item['params'] as $k => $v) { $regex = str_replace('{' . $k . '}', '(' . $v . ')', $regex); } if (preg_match('@^' . $regex . '$@', $url, $matches)) { array_shift($matches); if ($matches) { foreach ($item as $k1 => $v1) { $matches = array_combine(array_keys($item['params']), $matches); } } self::$controller = $item['controller'] . 'Controller'; self::$action = $item['action'] . 'Action'; $_GET = $matches + $_GET; break; } } if (is_null(self::$controller) || is_null(self::$action)) { throw new Exception('Page not found', 404); } }
/** * @param $url * @throws Exception * Метод для парсинга урла */ public static function parse($url) { $arr = explode('?', $url); $url = rtrim($arr[0], '/'); // если пусто - то на главную if (!$url) { self::$controller = 'IndexController'; self::$action = 'indexAction'; return; } // перебор роутов на предмет совпадения решулярки с урлом foreach (self::$routes as $route => $item) { $regex = $item['pattern']; foreach ($item['params'] as $k => $v) { $regex = str_replace('{' . $k . '}', '(' . $v . ')', $regex); } // если совпало if (preg_match('@^' . $regex . '$@', $url, $matches)) { array_shift($matches); if ($matches) { foreach ($item as $k1 => $v1) { $matches = array_combine(array_keys($item['params']), $matches); } } // определяем названия класса/метода контроллера self::$controller = $item['controller'] . 'Controller'; self::$action = $item['action'] . 'Action'; $_GET = $matches + $_GET; break; } } if (is_null(self::$controller) || is_null(self::$action)) { throw new Exception('Page not found', 404); } }
private function init() { //get user requested route if (isset($_GET['node'])) { //define route without parameters (helps with showing base URI request) $route = $_GET['node']; self::$route = $route; //break requested route into chunks in array $route_chunks = explode("/", $route); //define controller $controller = $route_chunks[0]; self::$controller = $controller; //define controller directory $controller_dir = CONTROLLER_DIR . $controller; self::$controller_dir = $controller_dir; //define format if (!empty($route_chunks[1])) { $format = $route_chunks[1]; self::$format = $format; } //define parameters - get full url etc and extract all strings after &.. global $settings; $request_uri = $settings['request_uri']; //break requested route into chunks in array $route_params = explode("&", $request_uri); //remove first value from array & return $route_params as just parameters $params_shift = array_shift($route_params); //update $params array foreach ($route_params as $val) { $param_chunks = explode("=", $val); $params[$param_chunks[0]] = $param_chunks[1]; } self::$params = $params; } }
static function route_controller($applicationName) { $url = parse_url($_SERVER['REQUEST_URI']); $path = explode('/', trim($url['path'], '/')); if (!isset($path[1])) { self::$controller = 'index'; self::$action = 'index'; } else { array_shift($path); $dir = $applicationName . '/controllers/'; foreach ($path as $p) { if (!is_dir($dir . $p . '/')) { break; } else { $dir .= $p . '/'; array_shift($path); } } self::$dir = $dir; //if (isset($path[0]) and $path[0] == 'index.php') self::$controller = array_shift($path); self::$action = array_shift($path); if (empty(self::$action)) { self::$action = 'index'; } } foreach ($path as $k => $v) { self::$params[$k] = $v; } return array(self::$controller, self::$action, self::$params); }
function call_fallback_page() { if (Router::$controller === NULL) { Router::$controller = 'fallback_page'; Router::$method = 'find_view'; Router::$controller_path = APPPATH . 'controllers/fallback_page.php'; } }
public function getController() { if (isset(self::$segments[0])) { self::$controller = self::$segments[0]; } else { self::$controller = 'index'; } }
/** * If Gallery is in maintenance mode, then force all non-admins to get routed to a "This site is * down for maintenance" page. */ static function maintenance_mode() { $maintenance_mode = Kohana::config("core.maintenance_mode", false, false); if (Router::$controller != "login" && !empty($maintenance_mode) && !user::active()->admin) { Router::$controller = "maintenance"; Router::$controller_path = MODPATH . "gallery/controllers/maintenance.php"; Router::$method = "index"; } }
public static function pareUrl() { if (isset($_GET['r'])) { $query_string = $_GET['r']; $query_string = explode('/', $query_string); self::$controller = $query_string[0]; self::$action = $query_string[1]; } }
/** * Add the chroot path at the begining of the requested URI */ static function parse_url() { if (user_chroot::album()) { if (Router::$controller == 'albums' && Router::$current_uri == '') { // Root album requested Router::$controller = null; Router::$current_uri = trim(user_chroot::album()->relative_url() . '/' . Router::$current_uri, '/'); } else { if (is_null(Router::$controller) && Router::$current_uri != '') { // Non-root album requested Router::$current_uri = trim(user_chroot::album()->relative_url() . '/' . Router::$current_uri, '/'); } } } return parent::parse_url(); }
static function parse_url() { if (Router::$controller) { return; } $count = count(Router::$segments); foreach (ORM::factory("item")->where("name", Router::$segments[$count - 1])->where("level", $count + 1)->find_all() as $match) { if ($match->relative_path() == Router::$current_uri) { $item = $match; } } if (!empty($item)) { Router::$controller = "{$item->type}s"; Router::$controller_path = APPPATH . "controllers/{$item->type}s.php"; Router::$method = $item->id; } }
protected function setUp() { // Save config $this->kohana_config['core.url_suffix'] = Kohana_Config::instance()->get('core.url_suffix'); // Save Server API $this->kohana_server_api = Kohana::$server_api; // Save Router members $this->router_vars = array('complete_uri' => Router::$complete_uri, 'controller' => Router::$controller, 'current_uri' => Router::$current_uri, 'query_string' => Router::$query_string, 'rsegments' => Router::$rsegments, 'routed_uri' => Router::$routed_uri, 'segments' => Router::$segments, 'url_suffix' => Router::$url_suffix); // Reset Router members Router::$complete_uri = ''; Router::$controller = NULL; Router::$current_uri = ''; Router::$query_string = ''; Router::$rsegments = NULL; Router::$routed_uri = ''; Router::$segments = NULL; Router::$url_suffix = ''; }
static function parse_url() { if (Router::$controller) { return; } // Work around problems with the CGI sapi by enforcing our default path if ($_SERVER["SCRIPT_NAME"] && "/" . Router::$current_uri == $_SERVER["SCRIPT_NAME"]) { Router::$controller_path = MODPATH . "gallery/controllers/albums.php"; Router::$controller = "albums"; Router::$method = 1; return; } $item = self::get_item_from_uri(Router::$current_uri); if ($item && $item->loaded) { Router::$controller = "{$item->type}s"; Router::$controller_path = MODPATH . "gallery/controllers/{$item->type}s.php"; Router::$method = $item->id; } }
static function parse_url() { if (Router::$controller) { return; } // Work around problems with the CGI sapi by enforcing our default path if ($_SERVER["SCRIPT_NAME"] && "/" . Router::$current_uri == $_SERVER["SCRIPT_NAME"]) { Router::$controller_path = MODPATH . "gallery/controllers/albums.php"; Router::$controller = "albums"; Router::$method = 1; return; } $item = item::find_by_relative_url(html_entity_decode(Router::$current_uri, ENT_QUOTES)); if ($item && $item->loaded()) { Router::$controller = "{$item->type}s"; Router::$controller_path = MODPATH . "gallery/controllers/{$item->type}s.php"; Router::$method = "show"; Router::$arguments = array($item); } }
public static function operation() { $filepath = Router::controller('filepath'); $classname = Router::controller('classname'); $method = Router::method(); $arguments = Router::arguments(); //加载controller if (file_exists($filepath)) { Zotop::load($filepath); } if (class_exists($classname, false)) { $controller = new $classname(); if (method_exists($controller, $method) && $method[0] != '_') { call_user_func_array(array($controller, $method), $arguments); } else { //Zotop::run('system.status.404'); //当方法不存在时,默认调用类的_empty()函数,改函数默认显示一个404错误,你可以在控制器中重写此方法 call_user_func_array(array($controller, '_empty'), $arguments); } } else { Zotop::run('system.status.404'); } }
private function _init() { $route = $this->_set_route(); $route = substr($route, -1, 1) == "/" ? substr($route, 0, -1) : $route; $route = $route ? explode("/", $route) : null; // define the controller directory if (isset(self::$config_route['controller_dir_in_route']) && self::$config_route['controller_dir_in_route'] === true) { if (is_array($route) && count($route)) { self::$controller_dir = array_shift($route); } elseif (isset(self::$config_route["default_controller_dir"])) { self::$config_route["default_controller_dir"]; } else { trigger_error("ROUTER: DEFAULT CONTROLLER DIR NOT SET"); } } // define the controller if (is_array($route) && count($route)) { self::$controller = array_shift($route); } elseif (isset(self::$config_route['default_controller'])) { self::$controller = self::$config_route["default_controller"]; } else { trigger_error("ROUTER: DEFAULT CONTROLLER NOT SET"); } // define action if (is_array($route) && count($route)) { self::$action = array_shift($route); } elseif (isset(self::$config_route['default_action'])) { self::$action = self::$config_route['default_action']; } else { trigger_error("ROUTER: DEFAULT ACTION NOT SET"); } // define the parameters if ($route) { self::$params = $route; } }
/** * If the gallery is only available to registered users and the user is not logged in, present * the login page. */ static function private_gallery() { if (identity::active_user()->guest && !access::user_can(identity::guest(), "view", item::root()) && php_sapi_name() != "cli") { try { $class = new ReflectionClass(ucfirst(Router::$controller) . '_Controller'); $allowed = $class->getConstant("ALLOW_PRIVATE_GALLERY") === true; } catch (ReflectionClass $e) { $allowed = false; } if (!$allowed) { if (Router::$controller == "admin") { // At this point we're in the admin theme and it doesn't have a themed login page, so // we can't just swap in the login controller and have it work. So redirect back to the // root item where we'll run this code again with the site theme. url::redirect(item::root()->abs_url()); } else { Session::instance()->set("continue_url", url::abs_current()); Router::$controller = "login"; Router::$controller_path = MODPATH . "gallery/controllers/login.php"; Router::$method = "html"; } } } }
public static function setController($str) { self::$controller = $str; }
/** * Setup routine. * Automatically called during the core initialization process. * @return bool * @throws Exception_Exido * @throws Exception_Exido_404 */ public static function initialize() { if (self::$_routes === null) { // Load routes self::$_routes = Exido::config('route'); } // Debug log if (Exido::$log_debug) { Exido::$log->add('EXIDO_DEBUG_LOG', __('Initialize routing')); } $default_route = false; if (self::$current_uri == Exido::config('global.core.index_file')) { self::$current_uri = ''; } if (!isset(self::$_routes['default_method'])) { self::$_routes['default_method'] = self::$method; } // Remove web-root directory if (WEB_ROOT != '') { self::$web_root = trim(WEB_ROOT, '/'); // Remove the suffix from the URL if needed self::$current_uri = trim(preg_replace("|^" . self::$web_root . "|", "", self::$current_uri), '/'); } if (self::$current_uri == '') { // If default controller is not set if (!isset(self::$_routes['default_controller']) or self::$_routes['default_controller'] == '') { self::$_routes['default_controller'] = self::$default; } // Use the default route when no segments exist self::$current_uri = self::$_routes['default_controller']; // Default route is in use $default_route = true; } if ($default_route == false) { // Remove the suffix from the URL if needed self::$current_uri = preg_replace("|" . preg_quote(Exido::config('global.core.url_suffix')) . "\$|", "", self::$current_uri); // Strip arguments if ($argspos = strpos(self::$current_uri, '?')) { self::$current_uri = substr(self::$current_uri, 0, $argspos); } // Explode the segments by slashes foreach (explode("/", preg_replace("|/*(.+?)/*\$|", "\\1", self::$current_uri)) as $val) { $val = trim($val); // Check for allowed characters if (Exido::config('global.core.permitted_uri_chars') != '' and $val != '') { // preg_quote() in PHP 5.3 escapes -, so the str_replace() and addition of - to preg_quote() is to maintain backwards // compatibility as many are unaware of how characters in the permitted_uri_chars will be parsed as a regex pattern if (!preg_match("|^[" . str_replace(array('\\-', '\\-'), '-', preg_quote(Exido::config('global.core.permitted_uri_chars'), '-')) . "]+\$|i", $val)) { throw new Exception_Exido('The requested URL %s has a disallowed characters', array($val)); } } if ($val != '') { self::$segments[] = self::$rsegments[] = $val; } } // Custom routing if (count(self::$_routes) > 0) { self::$rsegments = self::_getRouted(self::$segments); } //array_merge(self::_getRouted(self::$segments), self::$segments); } if ($default_route == true) { self::$rsegments[] = self::$current_uri; } // Prepare to find the controller $controller_path = ''; $method_segment = null; $controller_name = array(); // Paths to search $paths = Exido::getIncludePaths(); foreach (self::$rsegments as $key => $segment) { // Add the segment to the search path $controller_path .= $segment; $found = false; // Set segment into controller name $controller_name[] = ucfirst($segment); foreach ($paths as $dir) { // Search within controllers only $dir .= 'controller/'; if (is_dir($dir . $controller_path) or is_file($dir . $controller_path . '.php')) { // Valid path $found = true; // The controller must be a file that exists with the search path if ($c = realpath($dir . $controller_path . '.php') and is_file($c)) { // Set the controller name self::$controller = ucfirst(strtolower(EXIDO_ENVIRONMENT_NAME)) . '_Controller_' . implode('_', $controller_name); self::$controller_view = $controller_path; // Set the controller path self::$controller_path = $c; // Set the method $method_segment = $key + 1; // Stop searching break; } } } if ($found === false) { // Maximum depth has been reached, stop searching break; } // Add another slash $controller_path .= '/'; } if ($method_segment !== null and isset(self::$rsegments[$method_segment])) { // Set method if (isset(self::$rsegments[$method_segment])) { self::$method = self::$rsegments[$method_segment]; } if (isset(self::$rsegments[$method_segment])) { // Set arguments self::$arguments = array_slice(self::$rsegments, $method_segment + 1); } } // If controller does not found // We throw the 404 page if (self::$controller === null) { throw new Exception_Exido_404('Undefined controller %s.', array(self::$current_uri)); } return true; }
/** * Invokes method $method (with arguments $arguments) of the wrapped Controller, optionally replacing * $_GET and $_POST contents before making the call. * @param $method The name of the method to invoke. * @param $arguments The arguments to pass. * @param $get The array that should replace $_GET. * @param $post The array that should replace $_POST. * @param $capture If true (default) any output generated by the method is captured and returned, * otherwise the method's return value itself is returned. * @return The called method's output or its return value, depending on $capture. */ public function method($method, $arguments = null, $get = null, $post = null, $capture = true) { // If method does not exist, call the "__call" magic method // This can be made faster by catching an exception in the switch statement below if (!method_exists($this->controller, $method)) { $arguments = array($method, $arguments); $method = '__call'; } // Change Router state to reflect call //Router::$current_route = ''; //Router::$current_uri = ''; //Router::$complete_uri = ''; Router::$controller = $this->router_controller; Router::$method = $method; if ($arguments === null) { Router::$arguments = array(); } else { Router::$arguments = $arguments; } // If get or post parameters are passed, alter $_GET, $_POST and Router::$query_string accordingly // NOTE: Should we alter $_SERVER['QUERY_STRING'] too? if ($get !== null) { $old_get = $_GET; $_GET = $get; Router::$query_string = '?' . http_build_query($get); } if ($post !== null) { $old_post = $_POST; $_POST = $post; } // Start output capture if ($capture) { ob_implicit_flush(0); ob_start(); } if (is_string($arguments)) { $arguments = array($arguments); } // Invoke method switch (count($arguments)) { case 1: $result = $this->controller->{$method}($arguments[0]); break; case 2: $result = $this->controller->{$method}($arguments[0], $arguments[1]); break; case 3: $result = $this->controller->{$method}($arguments[0], $arguments[1], $arguments[2]); break; case 4: $result = $this->controller->{$method}($arguments[0], $arguments[1], $arguments[2], $arguments[3]); break; default: // Resort to using call_user_func_array for many arguments (slower) $result = call_user_func_array(array($this->controller, $method), $arguments); break; } // Run system.post_controller Event::run('dispatch.post_controller'); // Stop output capture if ($capture) { $result = ob_get_contents(); ob_end_clean(); } // Revert $_GET and $_POST changes if ($get !== null) { $_GET = $old_get; } if ($post !== null) { $_POST = $old_post; } // Revert Router state //Router::$current_route = $this->router_state_backup['current_route']; //Router::$current_uri = $this->router_state_backup['current_uri']; //Router::$complete_uri = $this->router_state_backup['complete_uri']; Router::$query_string = $this->router_state_backup['query_string']; Router::$controller = $this->router_state_backup['controller']; Router::$method = $this->router_state_backup['method']; Router::$arguments = $this->router_state_backup['arguments']; return $result; }
public static function init() { // find URI $uri = self::uri(); // remove query string from URI if (($query = strpos($uri, '?')) !== FALSE) { // split URI on question mark list($uri, $query) = explode('?', $uri, 2); // parse the query string into $_GET if using CLI // warning: converts spaces and dots to underscores if (PHP_SAPI === 'cli') { parse_str($query, $_GET); } } // store requested URI on first run only if (self::$current_uri === NULL) { self::$current_uri = trim($uri, '/'); } // matches a defined route $matched = FALSE; // match URI against route foreach (self::$routes as $route => $callback) { // trim slashes $route = trim($route, '/'); $callback = trim($callback, '/'); if (preg_match('#^' . $route . '$#u', self::$current_uri)) { if (strpos($callback, '$') !== FALSE) { // use regex routing self::$routed_uri = preg_replace('#^' . $route . '$#u', $callback, self::$current_uri); } else { // standard routing self::$routed_uri = $callback; } // valid route has been found $matched = TRUE; break; } } // no route matches found, use actual uri if (!$matched) { self::$routed_uri = self::$current_uri; } // use default route if requesting / if (empty(self::$routed_uri)) { self::$routed_uri = self::$routes['_default']; } // decipher controller/method $segments = explode('/', self::$routed_uri); // controller is first segment self::$controller = $segments[0]; // use default method if none specified self::$method = isset($segments[1]) ? $segments[1] : self::$method; // remaining arguments self::$arguments = array_slice($segments, 2); // instatiate controller self::execute(); }
public function error($role = false) { require CONTROLLER_PATH . 'Error.php'; Router::$controller = 'error'; $controller = new Error(); if ($role == true) { $controller->exePermission(); } else { $controller->exeDefault(); } return false; }
public static function parse($uri) { self::$action = Config::get('default_action'); self::$controller = Config::get('default_controller'); self::$language = Config::get('default_language'); self::$id = Config::get('default_id'); $uri_elements = self::url_to_array($uri); if (count($uri_elements)) { //if (strtolower(current($uri_elements) != 'admiin')) { if (in_array(strtolower(current($uri_elements)), Config::get('languages'))) { self::$language = strtolower(current($uri_elements)); array_shift($uri_elements); } //}else { // array_shift($uri_elements); //} $url = implode('/', $uri_elements); self::find_alias($url); /** if(current($uri_elements)){ self::$controller = ucfirst(strtolower(current($uri_elements))); array_shift($uri_elements); } if(current($uri_elements)){ self::$action = strtolower(current($uri_elements)); array_shift($uri_elements); } if(current($uri_elements)){ self::$params = $uri_elements; } **/ } }
/** * Determines the appropriate controller, method, and arguments * from the current URI request. * Where necessary, defaults will be employed. * Values are stored in local static members for use by the core. */ public static function current() { $current = self::getRequestPath(); // Are we being run from command line? if (PHP_SAPI === 'cli') { // $argv and $argc are disabled by default in some configurations. $argc = isset($argc) ? $argc : $_SERVER['argc']; if ($argc > 0) { $args = isset($argv) ? $argv : $_SERVER['argv']; // Merge all cli arguments as if they were in a uri from web context. $current = implode('/', $args); } else { $current = self::getRequestPath(); } } // Remove dot paths $current = preg_replace('#\\.[\\s./]*/#', '', $current); // Remove leading slash $current = ltrim($current, '/'); // Reduce multiple slashes $current = preg_replace('#//+#', '/', $current); // Remove front controller from URI if present (depends on variable used) $frontController = \Config::get('core.front_controller') . FILE_EXTENSION; if (substr($current, 0, strlen($frontController)) == $frontController) { $current = substr($current, strlen($frontController)); } // Remove any remaining leading/trailing slashes $current = trim($current, '/'); // Check for rewrites matching configuration values. $matched = $current; $rewrites = \Config::get('rewrites'); if (!empty($rewrites)) { foreach ($rewrites as $match => $replace) { $match = trim($match, '/'); // Exact match? if ($match == $current) { $matched = $replace; } elseif (preg_match('#^' . $match . '$#u', $current)) { if (strpos($replace, '$')) { // Replacement requires arguments that were parsed during match. $matched = preg_replace('#^' . $match . '$#u', $replace, $current); } else { // Found match, no parsed arguments required. $matched = $replace; } } } } $current = $matched; $parts = array(); if (strlen($current) > 0) { $parts = explode('/', $current); } if (empty($parts)) { self::$controller = \Config::get('core.default_controller'); } else { $controller = ''; while (count($parts)) { $controller .= array_shift($parts); if (Loader::search('controller' . DIRECTORY_SEPARATOR . $controller)) { self::$controller = $controller; if (count($parts)) { self::$method = array_shift($parts); } if (count($parts)) { self::$arguments = $parts; } } else { $controller .= DIRECTORY_SEPARATOR; } } } if (empty(self::$method)) { self::$method = \Config::get('core.default_controller_method'); } }
/** * Router setup routine. Automatically called during Kohana setup process. * * @return void */ public static function setup() { if (!empty($_SERVER['QUERY_STRING'])) { // Set the query string to the current query string Router::$query_string = '?' . trim($_SERVER['QUERY_STRING'], '&/'); } if (Router::$routes === NULL) { // Load routes Router::$routes = Kohana::config('routes'); } // Default route status $default_route = FALSE; if (Router::$current_uri === '') { // Make sure the default route is set if (!isset(Router::$routes['_default'])) { throw new Kohana_Exception('core.no_default_route'); } // Use the default route when no segments exist Router::$current_uri = Router::$routes['_default']; // Default route is in use $default_route = TRUE; } // Make sure the URL is not tainted with HTML characters Router::$current_uri = html::specialchars(Router::$current_uri, FALSE); // Remove all dot-paths from the URI, they are not valid Router::$current_uri = preg_replace('#\\.[\\s./]*/#', '', Router::$current_uri); // At this point segments, rsegments, and current URI are all the same Router::$segments = Router::$rsegments = Router::$current_uri = trim(Router::$current_uri, '/'); // Set the complete URI Router::$complete_uri = Router::$current_uri . Router::$query_string; // Explode the segments by slashes Router::$segments = ($default_route === TRUE or Router::$segments === '') ? array() : explode('/', Router::$segments); if ($default_route === FALSE and count(Router::$routes) > 1) { // Custom routing Router::$rsegments = Router::routed_uri(Router::$current_uri); } // The routed URI is now complete Router::$routed_uri = Router::$rsegments; // Routed segments will never be empty Router::$rsegments = explode('/', Router::$rsegments); // Prepare to find the controller $controller_path = ''; $method_segment = NULL; // Paths to search $paths = Kohana::include_paths(); foreach (Router::$rsegments as $key => $segment) { // Add the segment to the search path $controller_path .= $segment; $found = FALSE; foreach ($paths as $dir) { // Search within controllers only $dir .= 'controllers/'; if (is_dir($dir . $controller_path) or is_file($dir . $controller_path . EXT)) { // Valid path $found = TRUE; // The controller must be a file that exists with the search path if ($c = str_replace('\\', '/', realpath($dir . $controller_path . EXT)) and is_file($c) and strpos($c, $dir) === 0) { // Set controller name Router::$controller = $segment; // Change controller path Router::$controller_path = $c; // Set the method segment $method_segment = $key + 1; // Stop searching break; } } } if ($found === FALSE) { // Maximum depth has been reached, stop searching break; } // Add another slash $controller_path .= '/'; } if ($method_segment !== NULL and isset(Router::$rsegments[$method_segment])) { // Set method Router::$method = Router::$rsegments[$method_segment]; if (isset(Router::$rsegments[$method_segment + 1])) { // Set arguments Router::$arguments = array_slice(Router::$rsegments, $method_segment + 1); } } // Last chance to set routing before a 404 is triggered Event::run('system.post_routing'); if (Router::$controller === NULL) { // No controller was found, so no page can be rendered Event::run('system.404'); } }
/** * Determines the appropriate controller, method, and arguments * from the current URI request. * Where necessary, defaults will be employed. * Values are stored in local static members for use by the core. */ public static function current() { $current = $_SERVER['PHP_SELF']; // Are we being run from command line? if (PHP_SAPI === 'cli') { // $argv and $argc are disabled by default in some configurations. $argc = isset($argc) ? $argc : $_SERVER['argc']; if ($argc > 0) { $args = isset($argv) ? $argv : $_SERVER['argv']; // Merge all cli arguments as if they were in a uri from web context. $current = implode('/', $args); } else { $current = $_SERVER['PHP_SELF']; } } // Remove dot paths $current = preg_replace('#\\.[\\s./]*/#', '', $current); // Remove leading slash $current = ltrim($current, '/'); // Reduce multiple slashes $current = preg_replace('#//+#', '/', $current); // Remove front controller from URI $current = ltrim($current, Registry::$config['core']['front_controller'] . FILE_EXTENSION); // Remove any remaining leading/trailing slashes $current = trim($current, '/'); $parts = array(); if (strlen($current) > 0) { $parts = explode('/', $current); } /** * The controller is expected to be the first part. * If not supplied, we'll assume the default controller * defined in config. * * The method, if supplied, is expected to be the second part. * If not supplied, we'll assume that the default method defined * in config is the intended method. * * Any remaining parts are presumed to be arguments to the * method and will be treated as such. */ if (count($parts)) { self::$controller = array_shift($parts); } else { self::$controller = Registry::$config['core']['default_controller']; } if (count($parts)) { self::$method = array_shift($parts); } else { self::$method = Registry::$config['core']['default_controller_method']; } if (count($parts)) { self::$arguments = $parts; } }
<?php ini_set('display_errors', 1); ini_set('display_startup_errors', 1); error_reporting(E_ALL); require 'init.php'; if ($ctrl = Router::controller()) { include $ctrl; } else { header('HTTP/1.1 404 Not Found'); echo "Page not found!"; } //}}}
private function loadPageContent($pag) { Debug::log("Router - loadPageContent() ", __LINE__, __FUNCTION__, __CLASS__, __FILE__); $class = ucwords(str_replace("-", "_", $pag)) . "Controller"; $method = isset(self::$levels[$this->level_to_load_method]) ? self::$levels[$this->level_to_load_method] : "index"; $method = $this->checkFullUrlExist($class, $method); //Debug::p($class, $method); //echo "CHECK $class, $method :".method_exists($class,$method); //exit; if (class_exists($class)) { self::$controller = new $class(); //Debug::print_r("acceptNextIndexUnknownLevels: ".self::$controller->acceptNextIndexUnknownLevels); } if (class_exists($class) && method_exists($class, $method)) { for ($i = self::$levelRef + 2; $i < self::$levelRef; $i++) { $this->{$params}[$i - (self::$levelRef + 2)] = self::$levels[$i]; } Debug::log("Router->loadPageContent : Chamando metodo {$method} para a URL. (control/" . $pag . "_control.php) - {$class}"); Action::registerAccess(); Run::$ajaxMethod->start(); if (!isset(self::$controller->autoLoadMethod) || self::$controller->autoLoadMethod !== false) { Run::$benchmark->writeMark("startRouter/Inicio", "loadPageContent/if/controller/method"); self::$controller->{$method}(); } } else { if ((int) self::$controller->acceptNextIndexUnknownLevels > 0) { if (!isset(self::$controller->autoLoadMethod) || self::$controller->autoLoadMethod !== false) { $method = "index"; Debug::log("Router->loadPageContent : Chamando metodo index/{self::{$controller->acceptNextIndexUnknownLevels}} para a URL. (control/" . $pag . "_control.php) - {$class}"); Action::registerAccess(); Run::$benchmark->writeMark("startRouter/Inicio", "loadPageContent/else/controller/method"); if (method_exists($class, $method)) { self::$controller->{$method}(); } else { Error::show(8, "Router->loadPageContent: Metodo <b>{$method}</b> não existe. {self::{$controller->acceptNextUnknownLevels}} (control/" . $pag . "_control.php).", __FILE__, __LINE__); $this->load("404"); } } } else { if (!class_exists($class)) { Error::show(8, "Router->loadPageContent: Classe <b>{$class}</b> não existe. (control/" . $pag . "_control.php).", __FILE__, __LINE__); } else { Error::show(8, "Router->loadPageContent: Metodo <b>{$method}</b> não existe. {self::{$controller->acceptNextUnknownLevels}} (control/" . $pag . "_control.php).", __FILE__, __LINE__); } echo "<!-- {$class} ou {$method} não existe -->"; $this->load("404"); } } $this->flush(); //Run::$benchmark->writeMark("loadPageContent1", "loadPageContent2"); }