PHP Router::extensions方法代码示例

 /**
  * __construct
  *
  * @param CakeRequest $request
  * @param CakeResponse $response
  */
 public function __construct($request = null, $response = null)
 {
     parent::__construct($request, $response);
     if (count(Router::extensions())) {
         $this->components[] = 'RequestHandler';
     }
     $this->constructClasses();
     $this->Components->trigger('initialize', array(&$this));
     $this->_set(array('cacheAction' => false, 'viewPath' => 'Errors'));
     if (isset($this->RequestHandler)) {
         $this->RequestHandler->startup($this);
     }
 }

 /**
  * __construct
  *
  * @param CakeRequest $request
  * @param CakeResponse $response
  */
 public function __construct($request = null, $response = null)
 {
     parent::__construct($request, $response);
     $this->constructClasses();
     if (count(Router::extensions()) && !$this->Components->attached('RequestHandler')) {
         $this->RequestHandler = $this->Components->load('RequestHandler');
     }
     if ($this->Components->enabled('Auth')) {
         $this->Components->disable('Auth');
     }
     if ($this->Components->enabled('Security')) {
         $this->Components->disable('Security');
     }
     $this->_set(array('cacheAction' => false, 'viewPath' => 'Errors'));
 }

 /**
  * __construct
  *
  * @param CakeRequest $request
  * @param CakeResponse $response
  */
 public function __construct($request = null, $response = null)
 {
     parent::__construct($request, $response);
     if (count(Router::extensions()) && !array_key_exists('RequestHandler', $this->components) && !in_array('RequestHandler', $this->components, true)) {
         $this->components[] = 'RequestHandler';
     }
     $this->constructClasses();
     if ($this->Components->enabled('Auth')) {
         $this->Components->disable('Auth');
     }
     if ($this->Components->enabled('Security')) {
         $this->Components->disable('Security');
     }
     $this->startupProcess();
     $this->_set(array('cacheAction' => false, 'viewPath' => 'Errors'));
 }

 /**
  * __construct
  *
  * @param CakeRequest $request
  * @param CakeResponse $response
  */
 public function __construct(CakeRequest $request, CakeResponse $response)
 {
     parent::__construct($request, $response);
     if (count(Router::extensions())) {
         $this->components[] = 'RequestHandler';
     }
     try {
         $this->constructClasses();
         $this->startupProcess();
     } catch (CakeException $e) {
         CakeLog::write('critical', __d('croogo', 'Errors in CakeErrorController: %s', $e->getMessage()));
     }
     $this->_set(array('cacheAction' => false, 'viewPath' => 'Errors'));
     if (isset($this->RequestHandler)) {
         $this->RequestHandler->startup($this);
     }
 }

 public function __construct($request = null, $response = null)
 {
     parent::__construct($request, $response);
     $this->_mergeControllerVars();
     unset($this->components['Acl']);
     unset($this->components['Auth']);
     $this->Components->init($this);
     if ($this->uses) {
         $this->uses = (array) $this->uses;
         list(, $this->modelClass) = pluginSplit(current($this->uses));
     }
     if (count(Router::extensions()) && !$this->Components->attached('RequestHandler')) {
         $this->RequestHandler = $this->Components->load('RequestHandler');
     }
     if ($this->Components->enabled('Auth')) {
         $this->Components->disable('Auth');
     }
     if ($this->Components->enabled('Security')) {
         $this->Components->disable('Security');
     }
     $this->_set(array('cacheAction' => false, 'viewPath' => 'Errors'));
 }

 /**
  * testExtensionParsingSetting method
  *
  * @return void
  */
 public function testExtensionParsingSetting()
 {
     $this->assertEquals(array(), Router::extensions());
     Router::parseExtensions('rss');
     $this->assertEquals(Router::extensions(), array('rss'));
 }

 /**
  * Test that a type mismatch doesn't incorrectly set the ext
  *
  * @return void
  */
 public function testInitializeContentTypeAndExtensionMismatch()
 {
     $this->assertNull($this->RequestHandler->ext);
     $extensions = Router::extensions();
     Router::parseExtensions('xml');
     $this->Controller->request = $this->getMock('CakeRequest');
     $this->Controller->request->expects($this->any())->method('accepts')->will($this->returnValue(array('application/json')));
     $this->RequestHandler->initialize($this->Controller);
     $this->assertNull($this->RequestHandler->ext);
     call_user_func_array(array('Router', 'parseExtensions'), $extensions);
 }

 /**
  * Set the extension based on the accept headers.
  * Compares the accepted types and configured extensions.
  * If there is one common type, that is assigned as the ext/content type
  * for the response.
  *
  * If html is one of the preferred types, no content type will be set, this
  * is to avoid issues with browsers that prefer html and several other content types.
  *
  * @return void
  */
 protected function _setExtension()
 {
     $accept = $this->request->parseAccept();
     if (empty($accept)) {
         return;
     }
     $extensions = Router::extensions();
     $preferred = array_shift($accept);
     $preferredTypes = $this->response->mapType($preferred);
     if (!in_array('xhtml', $preferredTypes) && !in_array('html', $preferredTypes)) {
         $similarTypes = array_intersect($extensions, $preferredTypes);
         if (count($similarTypes) === 1) {
             $this->ext = array_shift($similarTypes);
         }
     }
 }

 /**
  * testSetExtensions method
  *
  * @return void
  */
 public function testSetExtensions()
 {
     Router::setExtensions(array('rss'));
     $this->assertEquals(array('rss'), Router::extensions());
     require CAKE . 'Config' . DS . 'routes.php';
     $result = Router::parse('/posts.rss');
     $this->assertFalse(isset($result['ext']));
     Router::parseExtensions();
     $result = Router::parse('/posts.rss');
     $this->assertEquals('rss', $result['ext']);
     $result = Router::parse('/posts.xml');
     $this->assertFalse(isset($result['ext']));
     Router::setExtensions(array('xml'));
     $result = Router::extensions();
     $this->assertEquals(array('rss', 'xml'), $result);
     $result = Router::parse('/posts.xml');
     $this->assertEquals('xml', $result['ext']);
     $result = Router::setExtensions(array('pdf'), false);
     $this->assertEquals(array('pdf'), $result);
 }

 /**
  * Set the extension based on the accept headers.
  * Compares the accepted types and configured extensions.
  * If there is one common type, that is assigned as the ext/content type
  * for the response.
  * Type with the highest weight will be set. If the highest weight has more
  * then one type matching the extensions, the order in which extensions are specified
  * determines which type will be set.
  *
  * If html is one of the preferred types, no content type will be set, this
  * is to avoid issues with browsers that prefer html and several other content types.
  *
  * @return void
  */
 protected function _setExtension()
 {
     $accept = $this->request->parseAccept();
     if (empty($accept)) {
         return;
     }
     $accepts = $this->response->mapType($this->request->parseAccept());
     $preferedTypes = current($accepts);
     if (array_intersect($preferedTypes, array('html', 'xhtml'))) {
         return null;
     }
     $extensions = Router::extensions();
     foreach ($accepts as $types) {
         $ext = array_intersect($extensions, $types);
         if ($ext) {
             $this->ext = current($ext);
             break;
         }
     }
 }

<?php

Router::connect('/admin', array('controller' => 'Welcome', 'action' => 'index', 'admin' => true, 'plugin' => 'trois'));
Router::connect('/sitemap', array('controller' => 'Sitemap', 'action' => 'index', 'admin' => false, 'plugin' => 'trois'));
$extentions = Router::extensions();
if (empty($extentions)) {
    Router::parseExtensions('json', 'xml');
} else {
    if (array_search('json', $extentions) === false) {
        array_push($extentions, 'json');
    }
    if (array_search('xml', $extentions) === false) {
        array_push($extentions, 'xml');
    }
    call_user_func_array('Router::parseExtensions', $extentions);
}

 /**
  * Initializes the component, gets a reference to Controller::$parameters, and
  * checks to see if a file extension has been parsed by the Router.  Or if the 
  * HTTP_ACCEPT_TYPE is set to a single value that is a supported extension and mapped type.
  * If yes, RequestHandler::$ext is set to that value
  *
  * @param object $controller A reference to the controller
  * @param array $settings Array of settings to _set().
  * @return void
  * @see Router::parseExtensions()
  */
 public function initialize($controller, $settings = array())
 {
     $this->request = $controller->request;
     $this->response = $controller->response;
     if (isset($this->request->params['url']['ext'])) {
         $this->ext = $this->request->params['url']['ext'];
     }
     if (empty($this->ext)) {
         $accepts = $this->request->accepts();
         $extensions = Router::extensions();
         if (count($accepts) == 1) {
             $mapped = $this->mapType($accepts[0]);
             if (in_array($mapped, $extensions)) {
                 $this->ext = $mapped;
             }
         }
     }
     $this->params = $controller->params;
     $this->_set($settings);
 }