PHP Generator\UrlGenerator类代码示例

 /**
  * @param $route_alias
  * @param $args
  * @return string
  */
 public function url($route_alias, $args = array())
 {
     $routes = $this->router->getRoutes();
     $context = new RequestContext(self::getAssetDirectory());
     $generator = new UrlGenerator($routes, $context);
     return $generator->generate($route_alias, $args);
 }

 /**
  * @Route("/url/{route}", bind="url", values={"route"=null})
  */
 public function urlAction($route)
 {
     if (null === $route) {
         $route = 'hello_name';
     }
     return $this->urlGenerator->generate($route, array('name' => 'urs'), UrlGeneratorInterface::ABSOLUTE_URL);
 }

 public function loginAction(Request $req, Twig_Environment $twig, SecurityContext $sc, UrlGenerator $urlgen)
 {
     if ($sc->isGranted('IS_AUTHENTICATED_FULLY')) {
         return new RedirectResponse($urlgen->generate('home'));
     } else {
         $session = $req->getSession();
         $errorConst = $sc::AUTHENTICATION_ERROR;
         $lastUsernameConst = $sc::LAST_USERNAME;
         return $twig->render('login.html.twig', array('error' => $session->has($errorConst) ? $session->get($errorConst)->getMessage() : null, 'last_username' => $session->get($lastUsernameConst)));
     }
 }

 public function path($routeName, $parameters = array())
 {
     /** @var Route $route */
     $route = $this->routes->get($routeName);
     if ($route) {
         $context = new RequestContext();
         $generator = new UrlGenerator($this->routes, $context);
         return $generator->generate($routeName, $parameters);
     }
     return '';
 }

 public static function generateURI($tag, $args = NULL)
 {
     $request = Request::createFromGlobals();
     $locator = new FileLocator(array(__DIR__));
     $loader = new YamlFileLoader($locator);
     $routes = $loader->load('../config/routes.yml');
     $context = new RequestContext($request->getBaseUrl());
     $generator = new UrlGenerator($routes, $context);
     $url = $generator->generate($tag);
     return $url;
 }

 /**
  * {@inheritDoc}
  */
 public function load(array $configs, ContainerBuilder $container)
 {
     $configuration = new Configuration();
     $config = $this->processConfiguration($configuration, $configs);
     $loader = new Loader\YamlFileLoader($container, new FileLocator(__DIR__ . '/../Resources/config'));
     $loader->load('services.yml');
     $container->setParameter('hearsay_require_js.require_js_src', $config['require_js_src']);
     $container->setParameter('hearsay_require_js.initialize_template', $config['initialize_template']);
     $container->setParameter('hearsay_require_js.base_url', $config['base_url']);
     $container->setParameter('hearsay_require_js.base_dir', $this->getRealPath($config['base_dir'], $container));
     // Add the base directory as an empty namespace
     $config['paths'][''] = array('location' => $config['base_dir'], 'external' => false);
     $hideUnoptimizedAssets = !isset($config['optimizer']['hide_unoptimized_assets']) ? false : $config['optimizer']['hide_unoptimized_assets'];
     // By using this flag as true, defines will be declared as their module names
     $declareModuleName = !isset($config['optimizer']['declare_module_name']) ? false : $config['optimizer']['declare_module_name'];
     $container->setParameter('hearsay_require_js.declare_module_name', $declareModuleName);
     foreach ($config['paths'] as $path => $settings) {
         $location = $settings['location'];
         if ($settings['external']) {
             $this->addExternalNamespaceMapping($location, $path, $container);
         } else {
             is_array($location) && ($location = array_shift($location));
             $this->addNamespaceMapping($location, $path, $container, !$hideUnoptimizedAssets);
         }
     }
     $container->setParameter('hearsay_require_js.shim', $config['shim']);
     $configurationBuilder = $container->getDefinition('hearsay_require_js.configuration_builder');
     foreach ($config['options'] as $option => $settings) {
         $configurationBuilder->addMethodCall('addOption', array($option, $settings['value']));
     }
     if (!isset($config['optimizer'])) {
         // If the r.js optimizer config isn't provided, don't provide the Assetic filter
         $container->removeDefinition('hearsay_require_js.optimizer_filter');
     } else {
         $container->setParameter('hearsay_require_js.r.path', $this->getRealPath($config['optimizer']['path'], $container));
         $filter = $container->getDefinition('hearsay_require_js.optimizer_filter');
         if ($config['optimizer']['almond_path']) {
             // Makes almond path relative to base directory for r.js optimization
             $almondPath = UrlGenerator::getRelativePath($container->getParameter('hearsay_require_js.base_dir'), $this->getRealPath($config['optimizer']['almond_path'], $container));
             // Removes file extension if it exists
             $almondPath = preg_replace('/\\.js$/', '', $almondPath);
             $filter->addMethodCall('setAlmondPath', array($almondPath));
             $configurationBuilder->addMethodCall('setUseAlmond', array(true));
         }
         $filter->addMethodCall('setShim', array($config['shim']));
         $filter->addMethodCall('setTimeout', array($config['optimizer']['timeout']));
         foreach ($config['optimizer']['exclude'] as $exclude) {
             $filter->addMethodCall('addExclude', array($exclude));
         }
         foreach ($config['optimizer']['modules'] as $name => $module) {
             $filter->addMethodCall('addModule', array($name, $module));
         }
         foreach ($config['optimizer']['options'] as $name => $settings) {
             $filter->addMethodCall('addOption', array($name, $settings['value']));
         }
     }
 }

 protected function getRouteUrl($name)
 {
     if (!isset($this->urlGenerator)) {
         throw new \Exception("URLGenerator was not set");
     }
     return $this->urlGenerator->generate($name);
 }

 public function testAbsoluteSecureUrlWithNonStandardPort()
 {
     $this->routeCollection->add('test', new Route('/testing'));
     $this->generator->setContext(array('base_url' => '/app.php', 'method' => 'GET', 'host' => 'localhost', 'port' => 8080, 'is_secure' => true));
     $url = $this->generator->generate('test', array(), true);
     $this->assertEquals('https://localhost:8080/app.php/testing', $url);
 }

 /**
  * @param GetResponseForExceptionEvent $event
  */
 public function onKernelException(GetResponseForExceptionEvent $event)
 {
     $exception = $event->getException();
     if ($exception instanceof NotInstalledException) {
         $response = new RedirectResponse($this->urlGenerator->generate('simplr_install_welcome'));
         $event->setResponse($response);
         return;
     }
 }

 public function generate($name, $parameters = [], $referenceType = self::ABSOLUTE_PATH)
 {
     if ($this->locale !== null && !isset($parameters[RouteAttribute::LOCALE])) {
         $parameters[RouteAttribute::LOCALE] = $this->locale;
     }
     return parent::generate($name, $parameters, $referenceType);
 }

 /**
  * {@override}
  */
 protected function doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $absolute)
 {
     if (is_object($parameters)) {
         $parameters = $this->readObjectParameters($parameters, $variables);
     }
     return parent::doGenerate($variables, $defaults, $requirements, $tokens, $parameters, $name, $absolute);
 }

 public function testListBucket()
 {
     $this->authorize();
     $listUrl = $this->urlGenerator->generate('list', ['bucket' => 'foo']);
     $listBuckets = new Result(['Buckets' => [['Name' => 'foo', 'CreationDate' => '2014-08-01T14:00:00.000Z'], ['Name' => 'bar', 'CreationDate' => '2014-07-31T20:30:40.000Z']]]);
     $listObjects = new Result(['Contents' => [['Key' => 'baz', 'ETag' => '"' . md5('baz') . '"', 'LastModified' => '2014-09-10T11:12:13.000Z', 'Size' => 1024], ['Key' => 'qux', 'ETag' => '"' . md5('qux') . '"', 'LastModified' => '2014-09-11T21:22:23.000Z', 'Size' => 2048], ['Key' => 'quxx', 'ETag' => '"' . md5('quxx') . '"', 'LastModified' => '2014-09-12T00:00:00.000Z', 'Size' => 512]], 'IsTruncated' => false]);
     $this->s3ClientMock->expects($this->once())->method('listBuckets')->willReturn($listBuckets);
     $this->s3ClientMock->expects($this->once())->method('listObjects')->willReturn($listObjects);
     $crawler = $this->client->request('GET', $listUrl);
     $this->assertTrue($this->client->getResponse()->isOk());
     // buckets
     $list = $crawler->filter('#list-bucket li');
     $active = $list->filter('.active');
     $this->assertCount(count($listBuckets['Buckets']), $list);
     $this->assertCount(1, $active);
     $this->assertEquals($list->eq(0), $active);
     $urlGenerator = $this->urlGenerator;
     $list->each(function (Crawler $bucket, $index) use($urlGenerator, $listBuckets) {
         $link = $bucket->filter('a');
         $expectedName = $listBuckets['Buckets'][$index]['Name'];
         $this->assertEquals($expectedName, $link->text());
         $this->assertEquals($urlGenerator->generate('list', ['bucket' => $expectedName]), $link->attr('href'));
     });
     // objects
     $list = $crawler->filter('#list-object tbody tr');
     $this->assertCount(count($listObjects['Contents']), $list);
     $list->each(function (Crawler $object, $index) use($listObjects) {
         $link = $object->filter('td')->eq(0)->filter('a');
         $expectedKey = $listObjects['Contents'][$index]['Key'];
         $this->assertEquals($expectedKey, $link->text());
         $this->assertEquals('http://foo.s3.amazonaws.com/' . $expectedKey, $link->attr('href'));
         $this->assertEquals($listObjects['Contents'][$index]['Size'], $object->filter('td')->eq(1)->text());
     });
 }

 /**
  * {@inheritdoc}
  */
 public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH)
 {
     // determine the most suitable locale to use for route generation
     $currentLocale = $this->context->getParameter('_locale');
     if (isset($parameters['_locale'])) {
         $locale = $parameters['_locale'];
     } else {
         if ($currentLocale) {
             $locale = $currentLocale;
         } else {
             $locale = 'en';
         }
     }
     try {
         if (false !== ($pos = strpos($name, I18nControllerCollection::ROUTING_PREFIX))) {
             $name = substr($name, $pos + strlen(I18nControllerCollection::ROUTING_PREFIX));
         }
         $url = parent::generate($locale . I18nControllerCollection::ROUTING_PREFIX . $name, $parameters, $referenceType);
         return $url;
     } catch (RouteNotFoundException $ex) {
         // fallback to default behavior
     }
     // use the default behavior if no localized route exists
     return parent::generate($name, $parameters, $referenceType);
 }

 /**
  * Get the URL to a named route.
  *
  * @param  string  $name
  * @param  array   $parameters
  * @param  bool    $absolute
  * @return string
  */
 public function route($name, $parameters = array(), $absolute = true)
 {
     $route = $this->routes->get($name);
     if (isset($route) and $this->usingQuickParameters($parameters)) {
         $parameters = $this->buildParameterList($route, $parameters);
     }
     return $this->generator->generate($name, $parameters, $absolute);
 }

 /**
  * {@inheritdoc}
  */
 public function generate($name, $parameters = array(), $referenceType = self::ABSOLUTE_PATH)
 {
     $url = parent::generate($name, $parameters, $referenceType);
     if (substr($url, -6) == '/index') {
         $url = rtrim($url, "index");
     }
     return $url;
 }