You are here

Home » API reference » Drupal 7 to 8/9 Module Upgrader 8 » Links.php

class Links in Drupal 7 to 8/9 Module Upgrader 8

Plugin annotation


@Converter(
 id = "links",
 description = @Translation("Converts Drupal 7's hook_menu() links to plugin definitions."),
 hook = "hook_menu",
 fixme = @Translation("@FIXME
This implementation of hook_menu() cannot be automatically converted because
it contains logic (i.e., branching statements, function calls, object
instantiation, etc.) You will need to convert it manually. Sorry!

For more information on how to convert hook_menu() to Drupal 8's new routing
and linking systems, see https://api.drupal.org/api/drupal/core%21includes%21menu.inc/group/menu/8"),
 dependencies = { "plugin.manager.drupalmoduleupgrader.route", "drupalmoduleupgrader.link_binding" }
)

Hierarchy

Expanded class hierarchy of Links

File

src/Plugin/DMU/Converter/Links.php, line 34

Namespace

Drupal\drupalmoduleupgrader\Plugin\DMU\Converter
View source 
class Links extends ConverterBase {

  /**
   * @var \Drupal\Component\Plugin\PluginManagerInterface
   */
  protected $routeConverters;

  /**
   * @var \Drupal\drupalmoduleupgrader\Routing\LinkBinding\LinkBindingFactory
   */
  protected $linkBinding;

  /**
   * Constructs a Links object.
   *
   * @param array $configuration
   *   Additional configuration for the plugin.
   * @param string $plugin_id
   *   The plugin ID, will be "Links".
   * @param string $plugin_definition
   *   The plugin definition as derived from the annotations.
   * @param \Drupal\Component\Plugin\PluginManagerInterface $route_converters
   *   The plugin manager for route converters, used by HookMenu.
   */
  public function __construct(array $configuration, $plugin_id, $plugin_definition, TranslationInterface $translator, LoggerInterface $log, PluginManagerInterface $route_converters, LinkBindingFactory $link_binding) {
    parent::__construct($configuration, $plugin_id, $plugin_definition, $translator, $log);
    $this->routeConverters = $route_converters;
    $this->linkBinding = $link_binding;
  }

  /**
   * {@inheritdoc}
   */
  public function convert(TargetInterface $target) {

    // If the hook implementation contains logic, we cannot convert it and
    // that's that. So we'll leave a FIXME and bail out.

    /** @var \Pharborist\Functions\FunctionDeclarationNode $hook */
    $hook = $target
      ->getIndexer('function')
      ->get('hook_menu');
    if ($hook
      ->is(new ContainsLogicFilter())) {
      $hook
        ->setDocComment(DocCommentNode::create($this->pluginDefinition['fixme']));
      $target
        ->save($hook);
      return;
    }

    // Links are split out by group because there are separate config files
    // for each link type.
    $links = [
      'menu' => new LinkIndex(),
      'task' => new LinkIndex(),
      'action' => new LinkIndex(),
      'contextual' => new LinkIndex(),
    ];
    $hook_menu = new HookMenu($target, $this->routeConverters);
    foreach ($hook_menu
      ->getSourceRoutes()
      ->getAllLinks() as $path => $source) {

      /** @var \Drupal\drupalmoduleupgrader\Routing\LinkBinding\LinkBinding $binding */
      $binding = $this->linkBinding
        ->create($source, $hook_menu
        ->getDestinationRoute($path));

      // Skip if the converter wasn't able to find a destination.
      $destination = $binding
        ->getDestination();
      if (empty($destination)) {
        continue;
      }
      if ($binding instanceof MenuLinkBinding) {
        $links['menu']
          ->addBinding($binding);
      }
      elseif ($binding instanceof LocalTaskLinkBinding) {
        $links['task']
          ->addBinding($binding);
      }
      elseif ($binding instanceof LocalActionLinkBinding) {
        $links['action']
          ->addBinding($binding);
      }
      elseif ($source
        ->isContextualLink()) {
        $links['contextual']
          ->addBinding($binding);
      }
    }
    $links = array_map(function (LinkIndex $index) {
      return $index
        ->build();
    }, $links);
    foreach ($links['contextual'] as $link) {
      $link['group'] = $target
        ->id();
    }
    foreach ($links as $group => $data) {
      if ($data) {
        $this
          ->writeInfo($target, 'links.' . $group, $data);
      }
    }
  }

}

Members

Namesort descending Modifiers Type Description Overrides
ConverterBase::buildFixMe protected function Builds a FIXME notice using either the text in the plugin definition, or passed-in text.
ConverterBase::DOC_COMMENT constant
ConverterBase::executeHook protected function Executes the target module's implementation of the specified hook, and returns the result.
ConverterBase::implement protected function Creates an empty implementation of a hook.
ConverterBase::isExecutable public function Returns if this conversion applies to the target module. If FALSE, the convert() method will not be called. Overrides ConverterInterface::isExecutable 4
ConverterBase::LINE_COMMENT constant
ConverterBase::parse protected function Parses a generated class into a syntax tree.
ConverterBase::rewriteFunction protected function Parametrically rewrites a function.
ConverterBase::write public function Writes a file to the target module's directory.
ConverterBase::writeClass public function Writes a class to the target module's PSR-4 root.
ConverterBase::writeInfo protected function Writes out arbitrary data in YAML format.
ConverterBase::writeService protected function Writes a service definition to the target module's services.yml file.
DependencySerializationTrait::$_entityStorages protected property An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds protected property An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
Links::$linkBinding protected property
Links::$routeConverters protected property
Links::convert public function Performs required conversions. Overrides ConverterInterface::convert
Links::__construct public function Constructs a Links object. Overrides PluginBase::__construct
MessengerTrait::$messenger protected property The messenger. 29
MessengerTrait::messenger public function Gets the messenger. 29
MessengerTrait::setMessenger public function Sets the messenger.
PluginBase::$configuration protected property Configuration information passed into the plugin. 1
PluginBase::$log protected property
PluginBase::$pluginDefinition protected property The plugin implementation definition. 1
PluginBase::$pluginId protected property The plugin_id.
PluginBase::create public static function Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create 2
PluginBase::DERIVATIVE_SEPARATOR constant A string which is used to separate base plugin IDs from the derivative ID.
PluginBase::getBaseId public function Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId public function Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition public function Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition 3
PluginBase::getPluginId public function Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
PluginBase::isConfigurable public function Determines if the plugin is configurable.
StringTranslationTrait::$stringTranslation protected property The string translation service. 1
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.