PHP Fuel::add_module方法代码示例

 public static function run($task, $args)
 {
     $task = strtolower($task);
     // Make sure something is set
     if (empty($task) or $task === 'help') {
         static::help();
         return;
     }
     $module = false;
     list($module, $task) = array_pad(explode('::', $task), 2, null);
     if ($task === null) {
         $task = $module;
         $module = false;
     }
     if ($module) {
         try {
             $path = \Fuel::add_module($module);
             \Finder::instance()->add_path($path);
         } catch (\FuelException $e) {
             throw new Exception(sprintf('Module "%s" does not exist.', $module));
         }
     }
     // Just call and run() or did they have a specific method in mind?
     list($task, $method) = array_pad(explode(':', $task), 2, 'run');
     // Find the task
     if (!($file = \Finder::search('tasks', $task))) {
         $files = \Finder::instance()->list_files('tasks');
         $possibilities = array();
         foreach ($files as $file) {
             $possible_task = pathinfo($file, \PATHINFO_FILENAME);
             $difference = levenshtein($possible_task, $task);
             $possibilities[$difference] = $possible_task;
         }
         ksort($possibilities);
         if ($possibilities and current($possibilities) <= 5) {
             throw new Exception(sprintf('Task "%s" does not exist. Did you mean "%s"?', $task, current($possibilities)));
         } else {
             throw new Exception(sprintf('Task "%s" does not exist.', $task));
         }
         return;
     }
     require_once $file;
     $task = '\\Fuel\\Tasks\\' . ucfirst($task);
     $new_task = new $task();
     // The help option hs been called, so call help instead
     if (\Cli::option('help') && is_callable(array($new_task, 'help'))) {
         $method = 'help';
     }
     if ($return = call_user_func_array(array($new_task, $method), $args)) {
         \Cli::write($return);
     }
 }

 /**
  * Find the controller that matches the route requested
  *
  * @param	Route		the given Route object
  * @return	mixed		the match array or false
  */
 protected static function find_controller($match)
 {
     // First port of call: request for a module?
     if (\Fuel::module_exists($match->segments[0])) {
         // make the module known to the autoloader
         \Fuel::add_module($match->segments[0]);
         $segments = $match->segments;
         // first check if the controller is in a directory.
         $match->module = array_shift($segments);
         $match->directory = count($segments) ? array_shift($segments) : null;
         $match->controller = count($segments) ? array_shift($segments) : $match->module;
         // does the module controller exist?
         if (class_exists(ucfirst($match->module) . '\\Controller_' . ucfirst($match->directory) . '_' . ucfirst($match->controller))) {
             $match->action = count($segments) ? array_shift($segments) : null;
             $match->method_params = $segments;
             return $match;
         }
         $segments = $match->segments;
         // then check if it's a module controller
         $match->module = array_shift($segments);
         $match->directory = null;
         $match->controller = count($segments) ? array_shift($segments) : $match->module;
         // does the module controller exist?
         if (class_exists(ucfirst($match->module) . '\\Controller_' . ucfirst($match->controller))) {
             $match->action = count($segments) ? array_shift($segments) : null;
             $match->method_params = $segments;
             return $match;
         }
         $segments = $match->segments;
         // do we have a module controller with the same name as the module?
         if ($match->controller != $match->module) {
             array_shift($segments);
             $match->controller = $match->module;
             if (class_exists(ucfirst($match->module) . '\\Controller_' . ucfirst($match->controller))) {
                 $match->action = count($segments) ? array_shift($segments) : null;
                 $match->method_params = $segments;
                 return $match;
             }
         }
     }
     $segments = $match->segments;
     // It's not a module, first check if the controller is in a directory.
     $match->directory = array_shift($segments);
     $match->controller = count($segments) ? array_shift($segments) : $match->directory;
     if (class_exists('Controller_' . ucfirst($match->directory) . '_' . ucfirst($match->controller))) {
         $match->action = count($segments) ? array_shift($segments) : null;
         $match->method_params = $segments;
         return $match;
     }
     $segments = $match->segments;
     // It's not in a directory, so check for app controllers
     $match->directory = null;
     $match->controller = count($segments) ? array_shift($segments) : $match->directory;
     // We first want to check if the controller is in a directory.
     if (class_exists('Controller_' . ucfirst($match->controller))) {
         $match->action = count($segments) ? array_shift($segments) : null;
         $match->method_params = $segments;
         return $match;
     }
     // none of the above. I give up. We've found ziltch...
     $match->action = null;
     $match->controller = null;
     return $match;
 }

 /**
  * Creates the new Request object by getting a new URI object, then parsing
  * the uri with the Route class.
  *
  * @access	public
  * @param	string	the uri string
  * @param	bool	whether or not to route the URI
  * @return	void
  */
 public function __construct($uri, $route)
 {
     $this->uri = new \URI($uri);
     $route = $route === true ? \Route::parse($this->uri) : \Route::parse_match($uri);
     // Attempts to register the first segment as a module
     $mod_path = \Fuel::add_module($route['segments'][0]);
     if ($mod_path !== false) {
         $this->module = array_shift($route['segments']);
         $this->paths = array($mod_path, $mod_path . 'classes' . DS);
     }
     // Check for directory
     $path = (!empty($this->module) ? $mod_path : APPPATH) . 'classes' . DS . 'controller' . DS;
     if (!empty($route['segments']) && is_dir($dirpath = $path . strtolower($route['segments'][0]))) {
         $this->directory = array_shift($route['segments']);
     }
     // When emptied the controller defaults to directory or module
     $controller = empty($this->directory) ? $this->module : $this->directory;
     if (count($route['segments']) == 0) {
         $route['segments'] = array($controller);
     }
     $this->controller = $route['segments'][0];
     $this->action = isset($route['segments'][1]) ? $route['segments'][1] : '';
     $this->method_params = array_slice($route['segments'], 2);
     $this->named_params = $route['named_params'];
     unset($route);
 }

 /**
  * Find the controller that matches the route requested
  *
  * @param	Route  $match  the given Route object
  * @return	mixed  the match array or false
  */
 protected static function parse_match($match)
 {
     $namespace = '';
     $segments = $match->segments;
     $module = false;
     // First port of call: request for a module?
     if (\Fuel::module_exists($segments[0])) {
         // make the module known to the autoloader
         \Fuel::add_module($segments[0]);
         $match->module = array_shift($segments);
         $namespace .= ucfirst($match->module) . '\\';
         $module = $match->module;
     }
     if ($info = static::parse_segments($segments, $namespace, $module)) {
         $match->controller = $info['controller'];
         $match->action = $info['action'];
         $match->method_params = $info['method_params'];
         return $match;
     } else {
         return null;
     }
 }

 /**
  * Creates the new Request object by getting a new URI object, then parsing
  * the uri with the Route class.
  *
  * Usage:
  *
  *     $request = new Request('foo/bar');
  *
  * @param   string  the uri string
  * @param   bool    whether or not to route the URI
  * @return  void
  */
 public function __construct($uri, $route = true)
 {
     $this->uri = new \Uri($uri);
     // check if a module was requested
     if (count($this->uri->segments) and $modpath = \Fuel::module_exists($this->uri->segments[0])) {
         // check if the module has routes
         if (file_exists($modpath .= 'config/routes.php')) {
             // load and add the module routes
             $modroutes = \Config::load(\Fuel::load($modpath), $this->uri->segments[0] . '_routes');
             foreach ($modroutes as $name => $modroute) {
                 switch ($name) {
                     case '_root_':
                         // map the root to the module default controller/method
                         $name = $this->uri->segments[0];
                         break;
                     case '_404_':
                         // do not touch the 404 route
                         break;
                     default:
                         // prefix the route with the module name if it isn't done yet
                         if (strpos($name, $this->uri->segments[0] . '/') !== 0 and $name != $this->uri->segments[0]) {
                             $name = $this->uri->segments[0] . '/' . $name;
                         }
                         break;
                 }
                 \Config::set('routes.' . $name, $modroute);
             }
             // update the loaded list of routes
             \Router::add(\Config::get('routes'));
         }
     }
     $this->route = \Router::process($this, $route);
     if (!$this->route) {
         return;
     }
     if ($this->route->module !== null) {
         $this->module = $this->route->module;
         \Fuel::add_module($this->module);
         $this->add_path(\Fuel::module_exists($this->module));
     }
     $this->directory = $this->route->directory;
     $this->controller = $this->route->controller;
     $this->action = $this->route->action;
     $this->method_params = $this->route->method_params;
     $this->named_params = $this->route->named_params;
 }

 public function callback($type, $finaliseUri, $bindto = null)
 {
     \Fuel::add_module('users');
     switch (strtolower($type)) {
         case 'facebook':
             \Fuel::add_package('facebook');
             if (\Facebook\Fb::getUser()) {
                 $me = \Facebook\Fb::api('/me');
                 if (!$me) {
                     throw new \Fuel_Exception('Could not retrieve facebook user info');
                 }
                 if (!$bindto || $bindto instanceof \Users\Model_User) {
                     $user = \Users\Model_User::find_by_facebook_id($me['id']);
                 } else {
                     $user = false;
                 }
                 if (\Auth::check()) {
                     $uid = \Auth::instance()->get_user_id();
                     if (!$user) {
                         //link user
                         $this->_linkfacebook($bindto ? $bindto : \Users\Model_User::find($uid[1]), $me);
                     } else {
                         if ($uid[1] != $user->id) {
                             \Session::set_flash('error', 'A user already exists with those facebook details. Please logout, login via facebook and unlink your facebook account and try again.');
                             \Response::redirect(\Input::get('redirect', '%2Flogin'));
                         }
                     }
                 } else {
                     if (!$user) {
                         //create & finalise
                         $user = \Auth::instance('UnifiedLogin')->create_user($me['email'], md5(rand()), $me['email'], 1, array('fname' => $me['first_name'], 'lname' => $me['last_name']));
                         $user = \Users\Model_User::find($user);
                         $this->_linkfacebook($user, $me);
                         \Auth::instance('UnifiedLogin')->forced_login($user);
                     } else {
                         //login found user
                         \Auth::instance('UnifiedLogin')->forced_login($user);
                     }
                 }
             } else {
                 throw new \Fuel_Exception('There was a problem getting the user in the callback.');
             }
             break;
         case 'twitter':
             \Fuel::add_package('twitter');
             $tokens = \Twitter\Tweet::instance()->get_tokens();
             $twitter_user = \Twitter\Tweet::instance()->call('get', 'account/verify_credentials');
             if (!$bindto || $bindto instanceof \Users\Model_User) {
                 $user = \Users\Model_User::find_by_twitter_id($twitter_user->id);
             } else {
                 $user = false;
             }
             if (\Auth::check()) {
                 $uid = \Auth::instance()->get_user_id();
                 if (!$user) {
                     //link user
                     $this->_linktwitter($bindto ? $bindto : \Users\Model_User::find($uid[1]), array("name" => $twitter_user->name, "id" => $twitter_user->id, "screen_name" => $twitter_user->screen_name));
                 } else {
                     if ($uid[1] != $user->id) {
                         \Session::set_flash('error', 'A user already exists with those twitter details. Please logout, login via facebook and unlink your facebook account and try again.');
                         \Response::redirect(\Input::get('redirect', '%2Flogin'));
                     }
                 }
             } else {
                 if (!$user) {
                     \Session::set('twitter_user_finalise', array("name" => $twitter_user->name, "id" => $twitter_user->id, "screen_name" => $twitter_user->screen_name));
                     \Response::redirect($finaliseUri);
                 } else {
                     //login found user
                     $this->forced_login($user);
                 }
             }
             break;
         case 'google':
             break;
         case 'openid':
             break;
         case 'auth':
             return parent::login($username, $password);
             break;
     }
 }

	/**
	 * Creates the new Request object by getting a new URI object, then parsing
	 * the uri with the Route class.
	 *
	 * Usage:
	 *
	 *     $request = new Request('foo/bar');
	 *
	 * @param   string  the uri string
	 * @param   bool    whether or not to route the URI
	 * @return  void
	 */
	public function __construct($uri, $route = true)
	{
		$this->uri = new \Uri($uri);

		// check if a module was requested
		if (count($this->uri->segments) and $modpath = \Fuel::module_exists($this->uri->segments[0]))
		{
			// check if the module has custom routes
			if (file_exists($modpath .= 'config/routes.php'))
			{
				// load and add the routes
				\Config::load(\Fuel::load($modpath), 'routes');
				\Router::add(\Config::get('routes'));
			}
		}

		$this->route = \Router::process($this, $route);

		if ( ! $this->route)
		{
			return false;
		}

		if ($this->route->module !== null)
		{
			$this->module = $this->route->module;
			\Fuel::add_module($this->module);
			$this->add_path(\Fuel::module_exists($this->module));
		}

		$this->directory = $this->route->directory;
		$this->controller = $this->route->controller;
		$this->action = $this->route->action;
		$this->method_params = $this->route->method_params;
		$this->named_params = $this->route->named_params;
	}