Move into nested docroot

web/core/modules/migrate_drupal/src/Annotation/MigrateCckField.php

@@ -0,0 +1,54 @@
+<?php
+
+namespace Drupal\migrate_drupal\Annotation;
+
+use Drupal\Component\Annotation\Plugin;
+
+/**
+ * Defines a cckfield plugin annotation object.
+ *
+ * cckfield plugins are variously responsible for handling the migration of
+ * CCK fields from Drupal 6 to Drupal 8, and Field API fields from Drupal 7
+ * to Drupal 8. They are allowed to alter CCK-related migrations when migrations
+ * are being generated, and can compute destination field types for individual
+ * fields during the actual migration process.
+ *
+ * Plugin Namespace: Plugin\migrate\cckfield
+ *
+ * @Annotation
+ */
+class MigrateCckField extends Plugin {
+
+  /**
+   * @inheritdoc
+   */
+  public function __construct($values) {
+    parent::__construct($values);
+    // Provide default value for core property, in case it's missing.
+    if (empty($this->definition['core'])) {
+      $this->definition['core'] = [6];
+    }
+  }
+
+  /**
+   * The plugin ID.
+   *
+   * @var string
+   */
+  public $id;
+
+  /**
+   * Map of D6 and D7 field types to D8 field type plugin IDs.
+   *
+   * @var string[]
+   */
+  public $type_map = [];
+
+  /**
+   * The Drupal core version(s) this plugin applies to.
+   *
+   * @var int[]
+   */
+  public $core = [];
+
+}

web/core/modules/migrate_drupal/src/MigrationConfigurationTrait.php

@@ -0,0 +1,170 @@
+<?php
+
+namespace Drupal\migrate_drupal;
+
+use Drupal\Core\Database\Connection;
+use Drupal\Core\Database\Database;
+use Drupal\migrate\Exception\RequirementsException;
+use Drupal\migrate\Plugin\RequirementsInterface;
+
+/**
+ * Configures the appropriate migrations for a given source Drupal database.
+ */
+trait MigrationConfigurationTrait {
+
+  /**
+   * Gets the database connection for the source Drupal database.
+   *
+   * @param array $database
+   *   Database array representing the source Drupal database.
+   *
+   * @return \Drupal\Core\Database\Connection
+   *   The database connection for the source Drupal database.
+   */
+  protected function getConnection(array $database) {
+    // Set up the connection.
+    Database::addConnectionInfo('upgrade', 'default', $database);
+    $connection = Database::getConnection('default', 'upgrade');
+    return $connection;
+  }
+
+  /**
+   * Gets the system data from the system table of the source Drupal database.
+   *
+   * @param \Drupal\Core\Database\Connection $connection
+   *   Database connection to the source Drupal database.
+   *
+   * @return array
+   *   The system data from the system table of the source Drupal database.
+   */
+  protected function getSystemData(Connection $connection) {
+    $system_data = [];
+    try {
+      $results = $connection->select('system', 's', [
+        'fetch' => \PDO::FETCH_ASSOC,
+      ])
+        ->fields('s')
+        ->execute();
+      foreach ($results as $result) {
+        $system_data[$result['type']][$result['name']] = $result;
+      }
+    }
+    catch (\Exception $e) {
+      // The table might not exist for example in tests.
+    }
+    return $system_data;
+  }
+
+  /**
+   * Creates the necessary state entries for SqlBase::getDatabase() to work.
+   *
+   * The state entities created here have to exist before migration plugin
+   * instances are created so that derivers such as
+   * \Drupal\taxonomy\Plugin\migrate\D6TermNodeDeriver can access the source
+   * database.
+   *
+   * @param array $database
+   *   The source database settings.
+   * @param string $drupal_version
+   *   The Drupal version.
+   *
+   * @see \Drupal\migrate\Plugin\migrate\source\SqlBase::getDatabase()
+   */
+  protected function createDatabaseStateSettings(array $database, $drupal_version) {
+    $database_state['key'] = 'upgrade';
+    $database_state['database'] = $database;
+    $database_state_key = 'migrate_drupal_' . $drupal_version;
+    \Drupal::state()->set($database_state_key, $database_state);
+    \Drupal::state()->set('migrate.fallback_state_key', $database_state_key);
+  }
+
+  /**
+   * Gets the migrations for import.
+   *
+   * @param string $database_state_key
+   *   The state key.
+   * @param int $drupal_version
+   *   The version of Drupal we're getting the migrations for.
+   *
+   * @return \Drupal\migrate\Plugin\MigrationInterface[]
+   *   The migrations for import.
+   */
+  protected function getMigrations($database_state_key, $drupal_version) {
+    $version_tag = 'Drupal ' . $drupal_version;
+    $plugin_manager = \Drupal::service('plugin.manager.migration');
+    /** @var \Drupal\migrate\Plugin\Migration[] $all_migrations */
+    $all_migrations = $plugin_manager->createInstancesByTag($version_tag);
+    $migrations = [];
+    foreach ($all_migrations as $migration) {
+      try {
+        // @todo https://drupal.org/node/2681867 We should be able to validate
+        //   the entire migration at this point.
+        $source_plugin = $migration->getSourcePlugin();
+        if ($source_plugin instanceof RequirementsInterface) {
+          $source_plugin->checkRequirements();
+        }
+        $destination_plugin = $migration->getDestinationPlugin();
+        if ($destination_plugin instanceof RequirementsInterface) {
+          $destination_plugin->checkRequirements();
+        }
+        $migrations[] = $migration;
+      }
+      catch (RequirementsException $e) {
+        // Migrations which are not applicable given the source and destination
+        // site configurations (e.g., what modules are enabled) will be silently
+        // ignored.
+      }
+    }
+
+    return $migrations;
+  }
+
+  /**
+   * Determines what version of Drupal the source database contains.
+   *
+   * @param \Drupal\Core\Database\Connection $connection
+   *   The database connection object.
+   *
+   * @return int|false
+   *   An integer representing the major branch of Drupal core (e.g. '6' for
+   *   Drupal 6.x), or FALSE if no valid version is matched.
+   */
+  protected function getLegacyDrupalVersion(Connection $connection) {
+    // Don't assume because a table of that name exists, that it has the columns
+    // we're querying. Catch exceptions and report that the source database is
+    // not Drupal.
+    // Drupal 5/6/7 can be detected by the schema_version in the system table.
+    if ($connection->schema()->tableExists('system')) {
+      try {
+        $version_string = $connection
+          ->query('SELECT schema_version FROM {system} WHERE name = :module', [':module' => 'system'])
+          ->fetchField();
+        if ($version_string && $version_string[0] == '1') {
+          if ((int) $version_string >= 1000) {
+            $version_string = '5';
+          }
+          else {
+            $version_string = FALSE;
+          }
+        }
+      }
+      catch (\PDOException $e) {
+        $version_string = FALSE;
+      }
+    }
+    // For Drupal 8 (and we're predicting beyond) the schema version is in the
+    // key_value store.
+    elseif ($connection->schema()->tableExists('key_value')) {
+      $result = $connection
+        ->query("SELECT value FROM {key_value} WHERE collection = :system_schema  and name = :module", [':system_schema' => 'system.schema', ':module' => 'system'])
+        ->fetchField();
+      $version_string = unserialize($result);
+    }
+    else {
+      $version_string = FALSE;
+    }
+
+    return $version_string ? substr($version_string, 0, 1) : FALSE;
+  }
+
+}

web/core/modules/migrate_drupal/src/MigrationCreationTrait.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Drupal\migrate_drupal;
+
+
+/**
+ * @deprecated in Drupal 8.1.x, will be removed before Drupal 9.0.0. Use
+ *   \Drupal\migrate_drupal\MigrationConfigurationTrait instead.
+ */
+trait MigrationCreationTrait {
+  use MigrationConfigurationTrait;
+
+}

web/core/modules/migrate_drupal/src/Plugin/MigrateCckFieldInterface.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin;
+
+use Drupal\Component\Plugin\PluginInspectionInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate\Row;
+
+/**
+ * Provides an interface for all CCK field type plugins.
+ */
+interface MigrateCckFieldInterface extends PluginInspectionInterface {
+
+  /**
+   * Apply any custom processing to the field migration.
+   *
+   * @param \Drupal\migrate\Plugin\MigrationInterface $migration
+   *   The migration entity.
+   */
+  public function processField(MigrationInterface $migration);
+
+  /**
+   * Apply any custom processing to the field instance migration.
+   *
+   * @param \Drupal\migrate\Plugin\MigrationInterface $migration
+   *   The migration entity.
+   */
+  public function processFieldInstance(MigrationInterface $migration);
+
+  /**
+   * Apply any custom processing to the field widget migration.
+   *
+   * @param \Drupal\migrate\Plugin\MigrationInterface $migration
+   *   The migration entity.
+   */
+  public function processFieldWidget(MigrationInterface $migration);
+
+  /**
+   * Apply any custom processing to the field formatter migration.
+   *
+   * @param \Drupal\migrate\Plugin\MigrationInterface $migration
+   *   The migration entity.
+   */
+  public function processFieldFormatter(MigrationInterface $migration);
+
+  /**
+   * Get a map between D6 formatters and D8 formatters for this field type.
+   *
+   * This is used by static::processFieldFormatter() in the base class.
+   *
+   * @return array
+   *   The keys are D6 formatters and the values are D8 formatters.
+   */
+  public function getFieldFormatterMap();
+
+  /**
+   * Get a map between D6 and D8 widgets for this field type.
+   *
+   * @return array
+   *   The keys are D6 field widget types and the values D8 widgets.
+   */
+  public function getFieldWidgetMap();
+
+  /**
+   * Apply any custom processing to the cck bundle migrations.
+   *
+   * @param \Drupal\migrate\Plugin\MigrationInterface $migration
+   *   The migration entity.
+   * @param string $field_name
+   *   The field name we're processing the value for.
+   * @param array $data
+   *   The array of field data from CckFieldValues::fieldData().
+   */
+  public function processCckFieldValues(MigrationInterface $migration, $field_name, $data);
+
+  /**
+   * Computes the destination type of a migrated field.
+   *
+   * @param \Drupal\migrate\Row $row
+   *   The field being migrated.
+   *
+   * @return string
+   *   The destination field type.
+   */
+  public function getFieldType(Row $row);
+
+}

web/core/modules/migrate_drupal/src/Plugin/MigrateCckFieldPluginManager.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin;
+
+use Drupal\Component\Plugin\Exception\PluginNotFoundException;
+use Drupal\migrate\Plugin\MigratePluginManager;
+use Drupal\migrate\Plugin\MigrationInterface;
+
+/**
+ * Plugin manager for migrate cckfield plugins.
+ *
+ * @see \Drupal\migrate_drupal\Plugin\MigrateCckFieldInterface
+ * @see \Drupal\migrate\Annotation\MigrateCckField
+ * @see plugin_api
+ *
+ * @ingroup migration
+ */
+class MigrateCckFieldPluginManager extends MigratePluginManager implements MigrateCckFieldPluginManagerInterface {
+
+  /**
+   * The default version of core to use for cck field plugins.
+   *
+   * These plugins were initially only built and used for Drupal 6 fields.
+   * Having been extended for Drupal 7 with a "core" annotation, we fall back to
+   * Drupal 6 where none exists.
+   */
+  const DEFAULT_CORE_VERSION = 6;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getPluginIdFromFieldType($field_type, array $configuration = [], MigrationInterface $migration = NULL) {
+    $core = static::DEFAULT_CORE_VERSION;
+    if (!empty($configuration['core'])) {
+      $core = $configuration['core'];
+    }
+    elseif (!empty($migration->getPluginDefinition()['migration_tags'])) {
+      foreach ($migration->getPluginDefinition()['migration_tags'] as $tag) {
+        if ($tag == 'Drupal 7') {
+          $core = 7;
+        }
+      }
+    }
+
+    foreach ($this->getDefinitions() as $plugin_id => $definition) {
+      if (in_array($core, $definition['core'])) {
+        if (array_key_exists($field_type, $definition['type_map']) || $field_type === $plugin_id) {
+          return $plugin_id;
+        }
+      }
+    }
+    throw new PluginNotFoundException($field_type);
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/MigrateCckFieldPluginManagerInterface.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin;
+
+use Drupal\migrate\Plugin\MigratePluginManagerInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+
+interface MigrateCckFieldPluginManagerInterface extends MigratePluginManagerInterface {
+
+  /**
+   * Get the plugin ID from the field type.
+   *
+   * @param string $field_type
+   *   The field type being migrated.
+   * @param array $configuration
+   *   (optional) An array of configuration relevant to the plugin instance.
+   * @param \Drupal\migrate\Plugin\MigrationInterface|null $migration
+   *   (optional) The current migration instance.
+   *
+   * @return string
+   *   The ID of the plugin for the field_type if available.
+   *
+   * @throws \Drupal\Component\Plugin\Exception\PluginNotFoundException
+   *   If the plugin cannot be determined, such as if the field type is invalid.
+   */
+  public function getPluginIdFromFieldType($field_type, array $configuration = [], MigrationInterface $migration = NULL);
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/CckMigration.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate;
+
+use Drupal\Component\Plugin\Exception\PluginNotFoundException;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\migrate\Exception\RequirementsException;
+use Drupal\migrate\Plugin\MigrateDestinationPluginManager;
+use Drupal\migrate\Plugin\MigratePluginManagerInterface;
+use Drupal\migrate\Plugin\Migration;
+use Drupal\migrate\Plugin\MigrationPluginManagerInterface;
+use Drupal\migrate\Plugin\RequirementsInterface;
+use Drupal\migrate_drupal\Plugin\MigrateCckFieldPluginManagerInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Migration plugin class for migrations dealing with CCK field values.
+ */
+class CckMigration extends Migration implements ContainerFactoryPluginInterface {
+
+  /**
+   * Flag indicating whether the CCK data has been filled already.
+   *
+   * @var bool
+   */
+  protected $init = FALSE;
+
+  /**
+   * List of cckfield plugin IDs which have already run.
+   *
+   * @var string[]
+   */
+  protected $processedFieldTypes = [];
+
+  /**
+   * Already-instantiated cckfield plugins, keyed by ID.
+   *
+   * @var \Drupal\migrate_drupal\Plugin\MigrateCckFieldInterface[]
+   */
+  protected $cckPluginCache;
+
+  /**
+   * The cckfield plugin manager.
+   *
+   * @var \Drupal\migrate_drupal\Plugin\MigrateCckFieldPluginManagerInterface
+   */
+  protected $cckPluginManager;
+
+  /**
+   * Constructs a CckMigration.
+   *
+   * @param array $configuration
+   *   Plugin configuration.
+   * @param string $plugin_id
+   *   The plugin ID.
+   * @param mixed $plugin_definition
+   *   The plugin definition.
+   * @param \Drupal\migrate_drupal\Plugin\MigrateCckFieldPluginManagerInterface $cck_manager
+   *   The cckfield plugin manager.
+   * @param \Drupal\migrate\Plugin\MigrationPluginManagerInterface $migration_plugin_manager
+   *   The migration plugin manager.
+   * @param \Drupal\migrate\Plugin\MigratePluginManagerInterface $source_plugin_manager
+   *   The source migration plugin manager.
+   * @param \Drupal\migrate\Plugin\MigratePluginManagerInterface $process_plugin_manager
+   *   The process migration plugin manager.
+   * @param \Drupal\migrate\Plugin\MigrateDestinationPluginManager $destination_plugin_manager
+   *   The destination migration plugin manager.
+   * @param \Drupal\migrate\Plugin\MigratePluginManagerInterface $idmap_plugin_manager
+   *   The ID map migration plugin manager.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, MigrateCckFieldPluginManagerInterface $cck_manager, MigrationPluginManagerInterface $migration_plugin_manager, MigratePluginManagerInterface $source_plugin_manager, MigratePluginManagerInterface $process_plugin_manager, MigrateDestinationPluginManager $destination_plugin_manager, MigratePluginManagerInterface $idmap_plugin_manager) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition, $migration_plugin_manager, $source_plugin_manager, $process_plugin_manager, $destination_plugin_manager, $idmap_plugin_manager);
+    $this->cckPluginManager = $cck_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('plugin.manager.migrate.cckfield'),
+      $container->get('plugin.manager.migration'),
+      $container->get('plugin.manager.migrate.source'),
+      $container->get('plugin.manager.migrate.process'),
+      $container->get('plugin.manager.migrate.destination'),
+      $container->get('plugin.manager.migrate.id_map')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getProcess() {
+    if (!$this->init) {
+      $this->init = TRUE;
+      $source_plugin = $this->migrationPluginManager->createInstance($this->pluginId)->getSourcePlugin();
+      if ($source_plugin instanceof RequirementsInterface) {
+        try {
+          $source_plugin->checkRequirements();
+        }
+        catch (RequirementsException $e) {
+          // Kill the rest of the method.
+          $source_plugin = [];
+        }
+      }
+      foreach ($source_plugin as $row) {
+        $field_type = $row->getSourceProperty('type');
+        try {
+          $plugin_id = $this->cckPluginManager->getPluginIdFromFieldType($field_type, [], $this);
+        }
+        catch (PluginNotFoundException $ex) {
+          continue;
+        }
+
+        if (!isset($this->processedFieldTypes[$field_type])) {
+          $this->processedFieldTypes[$field_type] = TRUE;
+          // Allow the cckfield plugin to alter the migration as necessary so
+          // that it knows how to handle fields of this type.
+          if (!isset($this->cckPluginCache[$field_type])) {
+            $this->cckPluginCache[$field_type] = $this->cckPluginManager->createInstance($plugin_id, [], $this);
+          }
+          call_user_func([$this->cckPluginCache[$field_type], $this->pluginDefinition['cck_plugin_method']], $this);
+        }
+      }
+    }
+    return parent::getProcess();
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/cckfield/CckFieldPluginBase.php

@@ -0,0 +1,83 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate\cckfield;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate\Row;
+use Drupal\migrate_drupal\Plugin\MigrateCckFieldInterface;
+
+/**
+ * The base class for all cck field plugins.
+ *
+ * @see \Drupal\migrate\Plugin\MigratePluginManager
+ * @see \Drupal\migrate_drupal\Annotation\MigrateCckField
+ * @see \Drupal\migrate_drupal\Plugin\MigrateCckFieldInterface
+ * @see plugin_api
+ *
+ * @ingroup migration
+ */
+abstract class CckFieldPluginBase extends PluginBase implements MigrateCckFieldInterface {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function processField(MigrationInterface $migration) {
+    $process[0]['map'][$this->pluginId][$this->pluginId] = $this->pluginId;
+    $migration->mergeProcessOfProperty('type', $process);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function processFieldInstance(MigrationInterface $migration) {
+    // Nothing to do by default with field instances.
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function processFieldWidget(MigrationInterface $migration) {
+    $process = [];
+    foreach ($this->getFieldWidgetMap() as $source_widget => $destination_widget) {
+      $process['type']['map'][$source_widget] = $destination_widget;
+    }
+    $migration->mergeProcessOfProperty('options/type', $process);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFieldWidgetMap() {
+    // By default, use the plugin ID for the widget types.
+    return [
+      $this->pluginId => $this->pluginId . '_default',
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function processFieldFormatter(MigrationInterface $migration) {
+    $process = [];
+    foreach ($this->getFieldFormatterMap() as $source_format => $destination_format) {
+      $process[0]['map'][$this->pluginId][$source_format] = $destination_format;
+    }
+    $migration->mergeProcessOfProperty('options/type', $process);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getFieldType(Row $row) {
+    $field_type = $row->getSourceProperty('type');
+
+    if (isset($this->pluginDefinition['type_map'][$field_type])) {
+      return $this->pluginDefinition['type_map'][$field_type];
+    }
+    else {
+      return $field_type;
+    }
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/destination/EntityFieldStorageConfig.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate\destination;
+
+use Drupal\Core\Entity\EntityStorageInterface;
+use Drupal\Core\Field\FieldTypePluginManagerInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate\Plugin\migrate\destination\EntityFieldStorageConfig as BaseEntityFieldStorageConfig;
+
+/**
+ * Deprecated. Destination with Drupal specific config dependencies.
+ *
+ * @MigrateDestination(
+ *   id = "md_entity:field_storage_config"
+ * )
+ *
+ * @deprecated in Drupal 8.2.x and will be removed in Drupal 9.0.x. Use
+ *   \Drupal\migrate\Plugin\migrate\destination\EntityFieldStorageConfig
+ *   instead.
+ *
+ * @see \Drupal\migrate\Plugin\migrate\destination\EntityFieldStorageConfig
+ */
+class EntityFieldStorageConfig extends BaseEntityFieldStorageConfig {
+
+  /**
+   * The field type plugin manager.
+   *
+   * @var \Drupal\Core\Field\FieldTypePluginManagerInterface
+   */
+  protected $fieldTypePluginManager;
+
+  /**
+   * Construct a new plugin.
+   *
+   * @param array $configuration
+   *   A configuration array containing information about the plugin instance.
+   * @param string $plugin_id
+   *   The plugin_id for the plugin instance.
+   * @param mixed $plugin_definition
+   *   The plugin implementation definition.
+   * @param \Drupal\migrate\Plugin\MigrationInterface $migration
+   *   The migration.
+   * @param EntityStorageInterface $storage
+   *   The storage for this entity type.
+   * @param array $bundles
+   *   The list of bundles this entity type has.
+   * @param \Drupal\Core\Field\FieldTypePluginManagerInterface $field_type_plugin_manager
+   *   The field type plugin manager.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration, EntityStorageInterface $storage, array $bundles, FieldTypePluginManagerInterface $field_type_plugin_manager) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition, $migration, $storage, $bundles);
+    $this->fieldTypePluginManager = $field_type_plugin_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration = NULL) {
+    $entity_type_id = static::getEntityTypeId($plugin_id);
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $migration,
+      $container->get('entity.manager')->getStorage($entity_type_id),
+      array_keys($container->get('entity.manager')->getBundleInfo($entity_type_id)),
+      $container->get('plugin.manager.field.field_type')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    $this->dependencies = parent::calculateDependencies();
+    // Add a dependency on the module that provides the field type using the
+    // source plugin configuration.
+    $source_configuration = $this->migration->getSourceConfiguration();
+    if (isset($source_configuration['constants']['type'])) {
+      $field_type = $this->fieldTypePluginManager->getDefinition($source_configuration['constants']['type']);
+      $this->addDependency('module', $field_type['provider']);
+    }
+    return $this->dependencies;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static function getEntityTypeId($plugin_id) {
+    return 'field_storage_config';
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/source/DrupalSqlBase.php

@@ -0,0 +1,178 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate\source;
+
+use Drupal\Component\Plugin\DependentPluginInterface;
+use Drupal\Core\Entity\DependencyTrait;
+use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\Core\State\StateInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate\Exception\RequirementsException;
+use Drupal\migrate\Plugin\migrate\source\SqlBase;
+use Drupal\migrate\Plugin\RequirementsInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * A base source class for Drupal migrate sources.
+ *
+ * Mainly to let children retrieve information from the origin system in an
+ * easier way.
+ */
+abstract class DrupalSqlBase extends SqlBase implements ContainerFactoryPluginInterface, RequirementsInterface, DependentPluginInterface {
+
+  use DependencyTrait;
+
+  /**
+   * The contents of the system table.
+   *
+   * @var array
+   */
+  protected $systemData;
+
+  /**
+   * If the source provider is missing.
+   *
+   * @var bool
+   */
+  protected $requirements = TRUE;
+
+  /**
+   * The entity manager.
+   *
+   * @var \Drupal\Core\Entity\EntityManagerInterface
+   */
+  protected $entityManager;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration, StateInterface $state, EntityManagerInterface $entity_manager) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition, $migration, $state);
+    $this->entityManager = $entity_manager;
+  }
+
+  /**
+   * Retrieves all system data information from origin system.
+   *
+   * @return array
+   *   List of system table information keyed by type and name.
+   */
+  public function getSystemData() {
+    if (!isset($this->systemData)) {
+      $this->systemData = array();
+      try {
+        $results = $this->select('system', 's')
+          ->fields('s')
+          ->execute();
+        foreach ($results as $result) {
+          $this->systemData[$result['type']][$result['name']] = $result;
+        }
+      }
+      catch (\Exception $e) {
+        // The table might not exist for example in tests.
+      }
+    }
+    return $this->systemData;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration = NULL) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $migration,
+      $container->get('state'),
+      $container->get('entity.manager')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function checkRequirements() {
+    if ($this->pluginDefinition['requirements_met'] === TRUE) {
+      if (isset($this->pluginDefinition['source_provider'])) {
+        if ($this->moduleExists($this->pluginDefinition['source_provider'])) {
+          if (isset($this->pluginDefinition['minimum_schema_version']) && !$this->getModuleSchemaVersion($this->pluginDefinition['source_provider']) < $this->pluginDefinition['minimum_schema_version']) {
+            throw new RequirementsException('Required minimum schema version ' . $this->pluginDefinition['minimum_schema_version'], ['minimum_schema_version' => $this->pluginDefinition['minimum_schema_version']]);
+          }
+        }
+        else {
+          throw new RequirementsException('The module ' . $this->pluginDefinition['source_provider'] . ' is not enabled in the source site.', ['source_provider' => $this->pluginDefinition['source_provider']]);
+        }
+      }
+    }
+  }
+
+  /**
+   * Get a module schema_version value in the source installation.
+   *
+   * @param string $module
+   *   Name of module.
+   *
+   * @return mixed
+   *   The current module schema version on the origin system table or FALSE if
+   *   not found.
+   */
+  protected function getModuleSchemaVersion($module) {
+    $system_data = $this->getSystemData();
+    return isset($system_data['module'][$module]['schema_version']) ? $system_data['module'][$module]['schema_version'] : FALSE;
+  }
+
+  /**
+   * Check to see if a given module is enabled in the source installation.
+   *
+   * @param string $module
+   *   Name of module to check.
+   *
+   * @return bool
+   *   TRUE if module is enabled on the origin system, FALSE if not.
+   */
+  protected function moduleExists($module) {
+    $system_data = $this->getSystemData();
+    return !empty($system_data['module'][$module]['status']);
+  }
+
+  /**
+   * Read a variable from a Drupal database.
+   *
+   * @param $name
+   *   Name of the variable.
+   * @param $default
+   *   The default value.
+   * @return mixed
+   */
+  protected function variableGet($name, $default) {
+    try {
+      $result = $this->select('variable', 'v')
+        ->fields('v', array('value'))
+        ->condition('name', $name)
+        ->execute()
+        ->fetchField();
+    }
+    // The table might not exist.
+    catch (\Exception $e) {
+      $result = FALSE;
+    }
+    return $result !== FALSE ? unserialize($result) : $default;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    // Generic handling for Drupal source plugin constants.
+    if (isset($this->configuration['constants']['entity_type'])) {
+      $this->addDependency('module', $this->entityManager->getDefinition($this->configuration['constants']['entity_type'])->getProvider());
+    }
+    if (isset($this->configuration['constants']['module'])) {
+      $this->addDependency('module', $this->configuration['constants']['module']);
+    }
+    return $this->dependencies;
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/source/EmptySource.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate\source;
+
+use Drupal\Component\Plugin\DependentPluginInterface;
+use Drupal\Core\Entity\DependencyTrait;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate\Plugin\migrate\source\EmptySource as BaseEmptySource;
+use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+
+
+/**
+ * Source returning an empty row with Drupal specific config dependencies.
+ *
+ * @MigrateSource(
+ *   id = "md_empty"
+ * )
+ */
+class EmptySource extends BaseEmptySource implements ContainerFactoryPluginInterface, DependentPluginInterface {
+
+  use DependencyTrait;
+
+  /**
+   * The entity manager.
+   *
+   * @var \Drupal\Core\Entity\EntityManagerInterface
+   */
+  protected $entityManager;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration, EntityManagerInterface $entity_manager) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition, $migration);
+    $this->entityManager = $entity_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration = NULL) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $migration,
+      $container->get('entity.manager')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    // The empty source plugin supports the entity_type constant.
+    if (isset($this->configuration['constants']['entity_type'])) {
+      $this->addDependency('module', $this->entityManager->getDefinition($this->configuration['constants']['entity_type'])->getProvider());
+    }
+    return $this->dependencies;
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/source/Variable.php

@@ -0,0 +1,90 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate\source;
+
+use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\State\StateInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+
+/**
+ * Drupal variable source from database.
+ *
+ * This source class always returns a single row and as such is not a good
+ * example for any normal source class returning multiple rows.
+ *
+ * @MigrateSource(
+ *   id = "variable"
+ * )
+ */
+class Variable extends DrupalSqlBase {
+
+  /**
+   * The variable names to fetch.
+   *
+   * @var array
+   */
+  protected $variables;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration, StateInterface $state, EntityManagerInterface $entity_manager) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition, $migration, $state, $entity_manager);
+    $this->variables = $this->configuration['variables'];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function initializeIterator() {
+    return new \ArrayIterator(array($this->values()));
+  }
+
+  /**
+   * Return the values of the variables specified in the plugin configuration.
+   *
+   * @return array
+   *   An associative array where the keys are the variables specified in the
+   *   plugin configuration and the values are the values found in the source.
+   *   Only those values are returned that are actually in the database.
+   */
+  protected function values() {
+    // Create an ID field so we can record migration in the map table.
+    // Arbitrarily, use the first variable name.
+    $values['id'] = reset($this->variables);
+    return $values + array_map('unserialize', $this->prepareQuery()->execute()->fetchAllKeyed());
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function count() {
+    return intval($this->query()->countQuery()->execute()->fetchField() > 0);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return array_combine($this->variables, $this->variables);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    return $this->getDatabase()
+      ->select('variable', 'v')
+      ->fields('v', array('name', 'value'))
+      ->condition('name', $this->variables, 'IN');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['id']['type'] = 'string';
+    return $ids;
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/source/VariableMultiRow.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate\source;
+
+use Drupal\migrate\Row;
+
+/**
+ * Multiple variables source from database.
+ *
+ * Unlike the variable source plugin, this one returns one row per
+ * variable.
+ *
+ * @MigrateSource(
+ *   id = "variable_multirow"
+ * )
+ */
+class VariableMultiRow extends DrupalSqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    return $this->select('variable', 'v')
+      ->fields('v', array('name', 'value'))
+      // Cast scalars to array so we can consistently use an IN condition.
+      ->condition('name', (array) $this->configuration['variables'], 'IN');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return array(
+      'name' => $this->t('Name'),
+      'value' => $this->t('Value'),
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    if ($value = $row->getSourceProperty('value')) {
+      $row->setSourceProperty('value', unserialize($value));
+    }
+    return parent::prepareRow($row);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['name']['type'] = 'string';
+    return $ids;
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/source/d6/i18nVariable.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate\source\d6;
+
+use Drupal\Core\Entity\EntityManagerInterface;
+use Drupal\Core\State\StateInterface;
+use Drupal\migrate\Plugin\MigrationInterface;
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+
+/**
+ * Drupal i18n_variable source from database.
+ *
+ * @MigrateSource(
+ *   id = "i18n_variable"
+ * )
+ */
+class i18nVariable extends DrupalSqlBase {
+
+  /**
+   * The variable names to fetch.
+   *
+   * @var array
+   */
+  protected $variables;
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, MigrationInterface $migration, StateInterface $state, EntityManagerInterface $entity_manager) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition, $migration, $state, $entity_manager);
+    $this->variables = $this->configuration['variables'];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function initializeIterator() {
+    return new \ArrayIterator($this->values());
+  }
+
+  /**
+   * Return the values of the variables specified in the plugin configuration.
+   *
+   * @return array
+   *   An associative array where the keys are the variables specified in the
+   *   plugin configuration and the values are the values found in the source.
+   *   A key/value pair is added for the language code. Only those values are
+   *   returned that are actually in the database.
+   */
+  protected function values() {
+    $values = [];
+    $result = $this->prepareQuery()->execute()->FetchAllAssoc('language');
+    foreach ($result as $i18n_variable) {
+      $values[]['language'] = $i18n_variable->language;
+    }
+    $result = $this->prepareQuery()->execute()->FetchAll();
+    foreach ($result as $i18n_variable) {
+      foreach ($values as $key => $value) {
+        if ($values[$key]['language'] === $i18n_variable->language) {
+          $values[$key][$i18n_variable->name] = unserialize($i18n_variable->value);
+          break;
+        }
+      }
+    }
+    return $values;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function count() {
+    return $this->initializeIterator()->count();
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return array_combine($this->variables, $this->variables);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    return $this->getDatabase()
+      ->select('i18n_variable', 'v')
+      ->fields('v')
+      ->condition('name', (array) $this->configuration['variables'], 'IN');
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['language']['type'] = 'string';
+    return $ids;
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/source/d7/FieldableEntity.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate\source\d7;
+
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+
+/**
+ * Base class for D7 source plugins which need to collect field values from
+ * the Field API.
+ */
+abstract class FieldableEntity extends DrupalSqlBase {
+
+  /**
+   * Returns all non-deleted field instances attached to a specific entity type.
+   *
+   * @param string $entity_type
+   *   The entity type ID.
+   * @param string|null $bundle
+   *   (optional) The bundle.
+   *
+   * @return array[]
+   *   The field instances, keyed by field name.
+   */
+  protected function getFields($entity_type, $bundle = NULL) {
+    return $this->select('field_config_instance', 'fci')
+      ->fields('fci')
+      ->condition('entity_type', $entity_type)
+      ->condition('bundle', isset($bundle) ? $bundle : $entity_type)
+      ->condition('deleted', 0)
+      ->execute()
+      ->fetchAllAssoc('field_name');
+  }
+
+  /**
+   * Retrieves field values for a single field of a single entity.
+   *
+   * @param string $entity_type
+   *   The entity type.
+   * @param string $field
+   *   The field name.
+   * @param int $entity_id
+   *   The entity ID.
+   * @param int|null $revision_id
+   *   (optional) The entity revision ID.
+   *
+   * @return array
+   *   The raw field values, keyed by delta.
+   *
+   * @todo Support multilingual field values.
+   */
+  protected function getFieldValues($entity_type, $field, $entity_id, $revision_id = NULL) {
+    $table = (isset($revision_id) ? 'field_revision_' : 'field_data_') . $field;
+    $query = $this->select($table, 't')
+      ->fields('t')
+      ->condition('entity_type', $entity_type)
+      ->condition('entity_id', $entity_id)
+      ->condition('deleted', 0);
+    if (isset($revision_id)) {
+      $query->condition('revision_id', $revision_id);
+    }
+    $values = [];
+    foreach ($query->execute() as $row) {
+      foreach ($row as $key => $value) {
+        $delta = $row['delta'];
+        if (strpos($key, $field) === 0) {
+          $column = substr($key, strlen($field) + 1);
+          $values[$delta][$column] = $value;
+        }
+      }
+    }
+    return $values;
+  }
+
+}

web/core/modules/migrate_drupal/src/Plugin/migrate/source/d8/Config.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Drupal\migrate_drupal\Plugin\migrate\source\d8;
+
+use Drupal\migrate\Row;
+use Drupal\migrate_drupal\Plugin\migrate\source\DrupalSqlBase;
+
+/**
+ * Drupal config source from database.
+ *
+ * @MigrateSource(
+ *   id = "d8_config"
+ * )
+ */
+class Config extends DrupalSqlBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function query() {
+    $query = $this->select('config', 'c')
+      ->fields('c', array('collection', 'name', 'data'));
+    if (!empty($this->configuration['collections'])) {
+      $query->condition('collection', (array) $this->configuration['collections'], 'IN');
+    }
+    if (!empty($this->configuration['names'])) {
+      $query->condition('name', (array) $this->configuration['names'], 'IN');
+    }
+    return $query;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRow(Row $row) {
+    $row->setSourceProperty('data', unserialize($row->getSourceProperty('data')));
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function fields() {
+    return [
+      'collection' => $this->t('The config object collection.'),
+      'name' => $this->t('The config object name.'),
+      'data' => $this->t('Serialized configuration object data.'),
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getIds() {
+    $ids['collection']['type'] = 'string';
+    $ids['name']['type'] = 'string';
+    return $ids;
+  }
+
+}

web/core/modules/migrate_drupal/src/Tests/StubTestTrait.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Drupal\migrate_drupal\Tests;
+
+use Drupal\migrate\Row;
+
+/**
+ * Provides common functionality for testing stubbing.
+ */
+trait StubTestTrait {
+
+  /**
+   * Test that creating a stub of the given entity type results in a valid
+   * entity.
+   *
+   * @param string $entity_type_id
+   *   The entity type we are stubbing.
+   */
+  protected function performStubTest($entity_type_id) {
+    $entity_id = $this->createStub($entity_type_id);
+    $this->assertTrue($entity_id, 'Stub successfully created');
+    if ($entity_id) {
+      $violations = $this->validateStub($entity_type_id, $entity_id);
+      if (!$this->assertIdentical(count($violations), 0, 'Stub is a valid entity')) {
+        foreach ($violations as $violation) {
+          $this->fail((string) $violation->getMessage());
+        }
+      }
+    }
+  }
+
+  /**
+   * Create a stub of the given entity type.
+   *
+   * @param string $entity_type_id
+   *   The entity type we are stubbing.
+   *
+   * @return int
+   *   ID of the created entity.
+   */
+  protected function createStub($entity_type_id) {
+    // Create a dummy migration to pass to the destination plugin.
+    $definition = [
+      'migration_tags' => ['Stub test'],
+      'source' => ['plugin' => 'empty'],
+      'process' => [],
+      'destination' => ['plugin' => 'entity:' . $entity_type_id],
+    ];
+    $migration = \Drupal::service('plugin.manager.migration')->createStubMigration($definition);
+    $destination_plugin = $migration->getDestinationPlugin(TRUE);
+    $stub_row = new Row([], [], TRUE);
+    $destination_ids = $destination_plugin->import($stub_row);
+    return reset($destination_ids);
+  }
+
+  /**
+   * Perform validation on a stub entity.
+   *
+   * @param string $entity_type_id
+   *   The entity type we are stubbing.
+   * @param string $entity_id
+   *   ID of the stubbed entity to validate.
+   *
+   * @return \Drupal\Core\Entity\EntityConstraintViolationListInterface
+   *   List of constraint violations identified.
+   */
+  protected function validateStub($entity_type_id, $entity_id) {
+    $controller = \Drupal::entityManager()->getStorage($entity_type_id);
+    /** @var \Drupal\Core\Entity\ContentEntityInterface $stub_entity */
+    $stub_entity = $controller->load($entity_id);
+    return $stub_entity->validate();
+  }
+
+}