PHP Url::createFromPath方法代码示例

 /**
  * {@inheritdoc}
  */
 public function validate($value, Constraint $constraint)
 {
     if (isset($value)) {
         $url_is_valid = TRUE;
         /** @var $link_item \Drupal\link\LinkItemInterface */
         $link_item = $value;
         $link_type = $link_item->getFieldDefinition()->getSetting('link_type');
         $url_string = $link_item->url;
         // Validate the url property.
         if ($url_string !== '') {
             try {
                 // @todo This shouldn't be needed, but massageFormValues() may not
                 //   run.
                 $parsed_url = UrlHelper::parse($url_string);
                 $url = Url::createFromPath($parsed_url['path']);
                 if ($url->isExternal() && !UrlHelper::isValid($url_string, TRUE)) {
                     $url_is_valid = FALSE;
                 } elseif ($url->isExternal() && !($link_type & LinkItemInterface::LINK_EXTERNAL)) {
                     $url_is_valid = FALSE;
                 }
             } catch (NotFoundHttpException $e) {
                 $url_is_valid = FALSE;
             } catch (MatchingRouteNotFoundException $e) {
                 $url_is_valid = FALSE;
             } catch (ParamNotConvertedException $e) {
                 $url_is_valid = FALSE;
             }
         }
         if (!$url_is_valid) {
             $this->context->addViolation($this->message, array('%url' => $url_string));
         }
     }
 }

 /**
  * Tests the createFromPath method.
  *
  * @covers ::createFromPath()
  * @covers ::setExternal()
  */
 public function testCreateFromPath()
 {
     $url = Url::createFromPath($this->path);
     $this->assertInstanceOf('Drupal\\Core\\Url', $url);
     $this->assertTrue($url->isExternal());
     return $url;
 }

 /**
  * {@inheritdoc}
  */
 public function getUrlObject()
 {
     if ($route_name = $this->getRouteName()) {
         $url = new Url($route_name, $this->getRouteParameters(), $this->getOptions());
     } else {
         $path = $this->getUrl();
         if (isset($path)) {
             $url = Url::createFromPath($path);
         } else {
             $url = new Url('<front>');
         }
     }
     return $url;
 }

 /**
  * Breaks up a user-entered URL or path into all the relevant parts.
  *
  * @param string $url
  *   The user-entered URL or path.
  *
  * @return array
  *   The extracted parts.
  */
 protected function extractUrl($url)
 {
     $extracted = UrlHelper::parse($url);
     $external = UrlHelper::isExternal($url);
     if ($external) {
         $extracted['url'] = $extracted['path'];
         $extracted['route_name'] = NULL;
         $extracted['route_parameters'] = array();
     } else {
         $extracted['url'] = '';
         // If the path doesn't match a Drupal path, the route should end up empty.
         $extracted['route_name'] = NULL;
         $extracted['route_parameters'] = array();
         try {
             // Find the route_name.
             $normal_path = $this->pathAliasManager->getPathByAlias($extracted['path']);
             $url_obj = Url::createFromPath($normal_path);
             $extracted['route_name'] = $url_obj->getRouteName();
             $extracted['route_parameters'] = $url_obj->getRouteParameters();
         } catch (MatchingRouteNotFoundException $e) {
             // The path doesn't match a Drupal path.
         } catch (ParamNotConvertedException $e) {
             // A path like node/99 matched a route, but the route parameter was
             // invalid (e.g. node with ID 99 does not exist).
         }
     }
     return $extracted;
 }

 /**
  * {@inheritdoc}
  */
 public function massageFormValues(array $values, array $form, array &$form_state)
 {
     foreach ($values as &$value) {
         if (!empty($value['url'])) {
             try {
                 $parsed_url = UrlHelper::parse($value['url']);
                 // If internal links are supported, look up whether the given value is
                 // a path alias and store the system path instead.
                 if ($this->supportsInternalLinks() && !UrlHelper::isExternal($value['url'])) {
                     $parsed_url['path'] = \Drupal::service('path.alias_manager')->getPathByAlias($parsed_url['path']);
                 }
                 $url = Url::createFromPath($parsed_url['path']);
                 $url->setOption('query', $parsed_url['query']);
                 $url->setOption('fragment', $parsed_url['fragment']);
                 $url->setOption('attributes', $value['attributes']);
                 $value += $url->toArray();
                 // Reset the URL value to contain only the path.
                 $value['url'] = $parsed_url['path'];
             } catch (NotFoundHttpException $e) {
                 // Nothing to do here, LinkTypeConstraintValidator emits errors.
             } catch (MatchingRouteNotFoundException $e) {
                 // Nothing to do here, LinkTypeConstraintValidator emits errors.
             } catch (ParamNotConvertedException $e) {
                 // Nothing to do here, LinkTypeConstraintValidator emits errors.
             }
         }
     }
     return $values;
 }

 /**
  * Tests the getRouteParameters() with an external URL.
  *
  * @covers ::getRouteParameters
  * @expectedException \UnexpectedValueException
  */
 public function testGetRouteParametersWithExternalUrl()
 {
     $url = Url::createFromPath('http://example.com');
     $url->getRouteParameters();
 }

 /**
  * {@inheritdoc}
  */
 public function preSave(EntityStorageInterface $storage)
 {
     parent::preSave($storage);
     $url = Url::createFromPath($this->path->value);
     $this->setRouteName($url->getRouteName());
     $this->setRouteParams($url->getRouteParameters());
 }

 /**
  * {@inheritdoc}
  */
 public function preSave(EntityStorageInterface $storage)
 {
     parent::preSave($storage);
     // This is the easiest way to handle the unique internal path '<front>',
     // since a path marked as external does not need to match a route.
     $this->external = UrlHelper::isExternal($this->link_path) || $this->link_path == '<front>' ? 1 : 0;
     // Try to find a parent link. If found, assign it and derive its menu.
     $parent = $this->findParent($storage);
     if ($parent) {
         $this->plid = $parent->id();
         $this->menu_name = $parent->menu_name;
     } else {
         $this->plid = 0;
     }
     // Directly fill parents for top-level links.
     if ($this->plid == 0) {
         $this->p1 = $this->id();
         for ($i = 2; $i <= MENU_MAX_DEPTH; $i++) {
             $parent_property = "p{$i}";
             $this->{$parent_property} = 0;
         }
         $this->depth = 1;
     } else {
         if ($this->has_children && $this->original) {
             $limit = MENU_MAX_DEPTH - $storage->findChildrenRelativeDepth($this->original) - 1;
         } else {
             $limit = MENU_MAX_DEPTH - 1;
         }
         if ($parent->depth > $limit) {
             return FALSE;
         }
         $this->depth = $parent->depth + 1;
         $this->setParents($parent);
     }
     // Need to check both plid and menu_name, since plid can be 0 in any menu.
     if (isset($this->original) && ($this->plid != $this->original->plid || $this->menu_name != $this->original->menu_name)) {
         $storage->moveChildren($this);
     }
     // Find the route_name.
     if (!$this->external && !isset($this->route_name)) {
         $url = Url::createFromPath($this->link_path);
         $this->route_name = $url->getRouteName();
         $this->route_parameters = $url->getRouteParameters();
     } elseif (empty($this->link_path)) {
         $this->link_path = \Drupal::urlGenerator()->getPathFromRoute($this->route_name, $this->route_parameters);
     }
 }

 /**
  * {@inheritdoc}
  */
 public function getUrlObject($title_attribute = TRUE)
 {
     $options = $this->getOptions();
     $description = $this->getDescription();
     if ($title_attribute && $description) {
         $options['attributes']['title'] = $description;
     }
     if (empty($this->pluginDefinition['url'])) {
         return new Url($this->pluginDefinition['route_name'], $this->pluginDefinition['route_parameters'], $options);
     } else {
         $url = Url::createFromPath($this->pluginDefinition['url']);
         $url->setOptions($options);
         return $url;
     }
 }

 /**
  * Entity URI callback.
  */
 public static function buildUri(ItemInterface $item)
 {
     return Url::createFromPath($item->getLink());
 }

 /**
  * Builds the \Drupal\Core\Url object for a link field item.
  *
  * @param \Drupal\link\LinkItemInterface $item
  *   The link field item being rendered.
  *
  * @return \Drupal\Core\Url
  *   An Url object.
  */
 protected function buildUrl(LinkItemInterface $item)
 {
     $settings = $this->getSettings();
     $options = $item->options;
     // Add optional 'rel' attribute to link options.
     if (!empty($settings['rel'])) {
         $options['attributes']['rel'] = $settings['rel'];
     }
     // Add optional 'target' attribute to link options.
     if (!empty($settings['target'])) {
         $options['attributes']['target'] = $settings['target'];
     }
     if ($item->isExternal()) {
         $url = Url::createFromPath($item->url);
         $url->setOptions($options);
     } else {
         $url = new Url($item->route_name, (array) $item->route_parameters, (array) $options);
     }
     return $url;
 }

 /**
  * Tests the generateFromUrl() method with an external URL.
  *
  * The set_active_class option is set to TRUE to ensure this does not cause
  * an error together with an external URL.
  *
  * @covers ::generateFromUrl()
  */
 public function testGenerateFromUrlExternal()
 {
     $this->urlGenerator->expects($this->once())->method('generateFromPath')->with('http://drupal.org', array('set_active_class' => TRUE, 'external' => TRUE) + $this->defaultOptions)->will($this->returnArgument(0));
     $this->moduleHandler->expects($this->once())->method('alter')->with('link', $this->isType('array'));
     $url = Url::createFromPath('http://drupal.org');
     $url->setUrlGenerator($this->urlGenerator);
     $url->setOption('set_active_class', TRUE);
     $result = $this->linkGenerator->generateFromUrl('Drupal', $url);
     $this->assertTag(array('tag' => 'a', 'attributes' => array('href' => 'http://drupal.org'), 'content' => 'Drupal'), $result);
 }