From 67f30bc0a1f0007f4725a87eb1f0b9525f5a9a8f Mon Sep 17 00:00:00 2001
From: Dries <dries@buytaert.net>
Date: Wed, 20 Nov 2013 17:08:56 -0500
Subject: [PATCH] Migrate in core #2125717 by mikeryan, chx, marvil07, bdone,
jessehs, mpgeek, BTMash, fastangel, mongolito404, Moshe Weitzman, eliza411,
YesCT, dawehner, cosmicdreams
---
.../migrate.migration.d6_system_cron.yml | 13 +
.../migrate.migration.d6_system_rss.yml | 10 +
.../migrate.migration.d6_system_site.yml | 24 +
.../lib/Drupal/migrate/Entity/Migration.php | 288 +++++++
.../migrate/Entity/MigrationInterface.php | 92 +++
.../lib/Drupal/migrate/MigrateException.php | 75 ++
.../lib/Drupal/migrate/MigrateExecutable.php | 538 +++++++++++++
.../lib/Drupal/migrate/MigrateMessage.php | 27 +
.../migrate/MigrateMessageInterface.php | 19 +
.../Plugin/MigrateDestinationInterface.php | 63 ++
.../migrate/Plugin/MigrateIdMapInterface.php | 241 ++++++
.../migrate/Plugin/MigratePluginManager.php | 60 ++
.../Plugin/MigrateProcessInterface.php | 36 +
.../migrate/Plugin/MigrateSourceInterface.php | 45 ++
.../migrate/Plugin/RequirementsInterface.php | 23 +
.../Plugin/migrate/destination/Config.php | 87 +++
.../migrate/destination/DestinationBase.php | 53 ++
.../migrate/Plugin/migrate/id_map/Sql.php | 705 ++++++++++++++++++
.../Plugin/migrate/process/DefaultValue.php | 29 +
.../migrate/Plugin/migrate/process/Get.php | 55 ++
.../Plugin/migrate/source/D6Variable.php | 59 ++
.../migrate/source/SourcePluginBase.php | 54 ++
.../migrate/Plugin/migrate/source/SqlBase.php | 192 +++++
.../migrate/source/d6/Drupal6SqlBase.php | 82 ++
.../migrate/lib/Drupal/migrate/Row.php | 264 +++++++
.../migrate/lib/Drupal/migrate/Source.php | 413 ++++++++++
.../migrate/Tests/Dump/Drupal6SystemCron.php | 59 ++
.../migrate/Tests/Dump/Drupal6SystemRss.php | 55 ++
.../migrate/Tests/Dump/Drupal6SystemSite.php | 75 ++
.../Tests/MigrateSystemConfigsTest.php | 75 ++
.../Drupal/migrate/Tests/MigrateTestBase.php | 60 ++
core/modules/migrate/migrate.api.php | 37 +
core/modules/migrate/migrate.info.yml | 7 +
core/modules/migrate/migrate.module | 0
core/modules/migrate/migrate.services.yml | 23 +
.../migrate/Tests/ConditionResolver.php | 93 +++
.../Drupal/migrate/Tests/D6VariableTest.php | 75 ++
.../Drupal/migrate/Tests/DatabaseRow.php | 19 +
.../migrate/Tests/DatabaseRowInterface.php | 13 +
.../migrate/Tests/DatabaseRowSelect.php | 28 +
.../migrate/Tests/FakeDatabaseSchema.php | 149 ++++
.../tests/Drupal/migrate/Tests/FakeSelect.php | 511 +++++++++++++
.../Drupal/migrate/Tests/FakeStatement.php | 103 +++
.../migrate/Tests/MigrateExecutableTest.php | 104 +++
.../Tests/MigrateSqlSourceTestCase.php | 88 +++
.../Drupal/migrate/Tests/MigrateTestCase.php | 141 ++++
.../tests/Drupal/migrate/Tests/TestSource.php | 18 +
.../Drupal/migrate/Tests/process/GetTest.php | 90 +++
.../Tests/process/MigrateProcessTestCase.php | 39 +
49 files changed, 5409 insertions(+)
create mode 100644 core/modules/migrate/config/migrate.migration.d6_system_cron.yml
create mode 100644 core/modules/migrate/config/migrate.migration.d6_system_rss.yml
create mode 100644 core/modules/migrate/config/migrate.migration.d6_system_site.yml
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Entity/Migration.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Entity/MigrationInterface.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/MigrateException.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/MigrateExecutable.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/MigrateMessage.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/MigrateMessageInterface.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateDestinationInterface.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateIdMapInterface.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/MigratePluginManager.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateProcessInterface.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateSourceInterface.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/RequirementsInterface.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/destination/Config.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/destination/DestinationBase.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/id_map/Sql.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/process/DefaultValue.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/process/Get.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/D6Variable.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/SourcePluginBase.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/SqlBase.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/d6/Drupal6SqlBase.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Row.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Source.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemCron.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemRss.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemSite.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Tests/MigrateSystemConfigsTest.php
create mode 100644 core/modules/migrate/lib/Drupal/migrate/Tests/MigrateTestBase.php
create mode 100644 core/modules/migrate/migrate.api.php
create mode 100644 core/modules/migrate/migrate.info.yml
create mode 100644 core/modules/migrate/migrate.module
create mode 100644 core/modules/migrate/migrate.services.yml
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/ConditionResolver.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/D6VariableTest.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRow.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRowInterface.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRowSelect.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/FakeDatabaseSchema.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/FakeSelect.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/FakeStatement.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/MigrateExecutableTest.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/MigrateSqlSourceTestCase.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/MigrateTestCase.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/TestSource.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/process/GetTest.php
create mode 100644 core/modules/migrate/tests/Drupal/migrate/Tests/process/MigrateProcessTestCase.php
diff --git a/core/modules/migrate/config/migrate.migration.d6_system_cron.yml b/core/modules/migrate/config/migrate.migration.d6_system_cron.yml
new file mode 100644
index 000000000000..736af9ba60d5
--- /dev/null
+++ b/core/modules/migrate/config/migrate.migration.d6_system_cron.yml
@@ -0,0 +1,13 @@
+id: d6_system_cron
+source:
+ plugin: drupal6_variable
+ variables:
+ - cron_threshold_warning
+ - cron_threshold_error
+ - cron_last
+process:
+ 'threshold:warning': cron_threshold_warning
+ 'threshold:error': cron_threshold_error
+destination:
+ plugin: d8_config
+ config_name: system.cron
diff --git a/core/modules/migrate/config/migrate.migration.d6_system_rss.yml b/core/modules/migrate/config/migrate.migration.d6_system_rss.yml
new file mode 100644
index 000000000000..acce5e2aec78
--- /dev/null
+++ b/core/modules/migrate/config/migrate.migration.d6_system_rss.yml
@@ -0,0 +1,10 @@
+id: d6_system_rss
+source:
+ plugin: drupal6_variable
+ variables:
+ - feed_default_items
+process:
+ 'items:limit': feed_default_items
+destination:
+ plugin: d8_config
+ config_name: system.rss
diff --git a/core/modules/migrate/config/migrate.migration.d6_system_site.yml b/core/modules/migrate/config/migrate.migration.d6_system_site.yml
new file mode 100644
index 000000000000..bcfb712dbbe2
--- /dev/null
+++ b/core/modules/migrate/config/migrate.migration.d6_system_site.yml
@@ -0,0 +1,24 @@
+id: d6_system_site
+source:
+ plugin: drupal6_variable
+ variables:
+ - site_name
+ - site_mail
+ - site_slogan
+ - site_frontpage
+ - site_403
+ - site_404
+ - drupal_weight_select_max
+ - admin_compact_mode
+process:
+ name: site_name
+ mail: site_mail
+ slogan: site_slogan
+ 'page:front': site_frontpage
+ 'page:403': site_403
+ 'page:404': site_404
+ weight_select_max: drupal_weight_select_max
+ admin_compact_mode: admin_compact_mode
+destination:
+ plugin: d8_config
+ config_name: system.site
diff --git a/core/modules/migrate/lib/Drupal/migrate/Entity/Migration.php b/core/modules/migrate/lib/Drupal/migrate/Entity/Migration.php
new file mode 100644
index 000000000000..5d48ed0ddae1
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Entity/Migration.php
@@ -0,0 +1,288 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Entity\Migration.
+ */
+
+namespace Drupal\migrate\Entity;
+
+use Drupal\Core\Config\Entity\ConfigEntityBase;
+use Drupal\migrate\MigrateException;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+
+/**
+ * Defines the Migration entity.
+ *
+ * The migration entity stores the information about a single migration, like
+ * the source, process and destination plugins.
+ *
+ * @EntityType(
+ * id = "migration",
+ * label = @Translation("Migration"),
+ * module = "migrate",
+ * controllers = {
+ * "storage" = "Drupal\Core\Config\Entity\ConfigStorageController",
+ * "list" = "Drupal\Core\Config\Entity\DraggableListController",
+ * "access" = "Drupal\Core\Entity\EntityAccessController",
+ * "form" = {
+ * "add" = "Drupal\Core\Entity\EntityFormController",
+ * "edit" = "Drupal\Core\Entity\EntityFormController",
+ * "delete" = "Drupal\Core\Entity\EntityFormController"
+ * }
+ * },
+ * config_prefix = "migrate.migration",
+ * entity_keys = {
+ * "id" = "id",
+ * "label" = "label",
+ * "weight" = "weight",
+ * "uuid" = "uuid"
+ * }
+ * )
+ */
+class Migration extends ConfigEntityBase implements MigrationInterface {
+
+ /**
+ * The migration ID (machine name).
+ *
+ * @var string
+ */
+ public $id;
+
+ /**
+ * The migration UUID.
+ *
+ * This is assigned automatically when the migration is created.
+ *
+ * @var string
+ */
+ public $uuid;
+
+ /**
+ * The human-readable label for the migration.
+ *
+ * @var string
+ */
+ public $label;
+
+ /**
+ * The plugin ID for the row.
+ *
+ * @var string
+ */
+ public $row;
+
+ /**
+ * The source configuration, with at least a 'plugin' key.
+ *
+ * Used to initialize the $sourcePlugin.
+ *
+ * @var array
+ */
+ public $source;
+
+ /**
+ * The source plugin.
+ *
+ * @var \Drupal\migrate\Plugin\MigrateSourceInterface
+ */
+ protected $sourcePlugin;
+
+ /**
+ * The configuration describing the process plugins.
+ *
+ * @var array
+ */
+ public $process;
+
+ /**
+ * The destination configuration, with at least a 'plugin' key.
+ *
+ * Used to initialize $destinationPlugin.
+ *
+ * @var array
+ */
+ public $destination;
+
+ /**
+ * The destination plugin.
+ *
+ * @var \Drupal\migrate\Plugin\MigrateDestinationInterface
+ */
+ protected $destinationPlugin;
+
+ /**
+ * The identifier map data.
+ *
+ * Used to initialize $idMapPlugin.
+ *
+ * @var string
+ */
+ public $idMap = array();
+
+ /**
+ * The identifier map.
+ *
+ * @var \Drupal\migrate\Plugin\MigrateIdMapInterface
+ */
+ protected $idMapPlugin;
+
+ /**
+ * The source identifiers.
+ *
+ * An array of source identifiers: the keys are the name of the properties,
+ * the values are dependent on the ID map plugin.
+ *
+ * @var array
+ */
+ public $sourceIds = array();
+
+ /**
+ * The destination identifiers.
+ *
+ * An array of destination identifiers: the keys are the name of the
+ * properties, the values are dependent on the ID map plugin.
+ *
+ * @var array
+ */
+ public $destinationIds = array();
+
+ /**
+ * Information on the highwater mark.
+ *
+ * @var array
+ */
+ public $highwaterProperty;
+
+ /**
+ * Indicate whether the primary system of record for this migration is the
+ * source, or the destination (Drupal). In the source case, migration of
+ * an existing object will completely replace the Drupal object with data from
+ * the source side. In the destination case, the existing Drupal object will
+ * be loaded, then changes from the source applied; also, rollback will not be
+ * supported.
+ *
+ * @var string
+ */
+ public $systemOfRecord = self::SOURCE;
+
+ /**
+ * Specify value of needs_update for current map row. Usually set by
+ * MigrateFieldHandler implementations.
+ *
+ * @var int
+ */
+ public $needsUpdate = MigrateIdMapInterface::STATUS_IMPORTED;
+
+ /**
+ * @var \Drupal\Core\KeyValueStore\KeyValueStoreInterface
+ */
+ protected $highwaterStorage;
+
+ /**
+ * @var bool
+ */
+ public $trackLastImported = FALSE;
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getSourcePlugin() {
+ if (!isset($this->sourcePlugin)) {
+ $this->sourcePlugin = \Drupal::service('plugin.manager.migrate.source')->createInstance($this->source['plugin'], $this->source, $this);
+ }
+ return $this->sourcePlugin;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getProcessPlugins(array $process = NULL) {
+ if (!isset($process)) {
+ $process = $this->process;
+ }
+ $process_plugins = array();
+ foreach ($this->getProcessNormalized($process) as $property => $configurations) {
+ $process_plugins[$property] = array();
+ foreach ($configurations as $configuration) {
+ if (isset($configuration['source'])) {
+ $process_plugins[$property][] = \Drupal::service('plugin.manager.migrate.process')->createInstance('get', $configuration, $this);
+ }
+ // Get is already handled.
+ if ($configuration['plugin'] != 'get') {
+ $process_plugins[$property][] = \Drupal::service('plugin.manager.migrate.process')->createInstance($configuration['plugin'], $configuration, $this);
+ }
+ if (!$process_plugins[$property]) {
+ throw new MigrateException("Invalid process configuration for $property");
+ }
+ }
+ }
+ return $process_plugins;
+ }
+
+ /**
+ * Resolve shorthands into a list of plugin configurations.
+ *
+ * @param array $process
+ * A process configuration array.
+ *
+ * @return array
+ * The normalized process configuration.
+ */
+ protected function getProcessNormalized(array $process) {
+ $normalized_configurations = array();
+ foreach ($process as $destination => $configuration) {
+ if (is_string($configuration)) {
+ $configuration = array(
+ 'plugin' => 'get',
+ 'source' => $configuration,
+ );
+ }
+ if (isset($configuration['plugin'])) {
+ $configuration = array($configuration);
+ }
+ $normalized_configurations[$destination] = $configuration;
+ }
+ return $normalized_configurations;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getDestinationPlugin() {
+ if (!isset($this->destinationPlugin)) {
+ $this->destinationPlugin = \Drupal::service('plugin.manager.migrate.destination')->createInstance($this->destination['plugin'], $this->destination, $this);
+ }
+ return $this->destinationPlugin;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getIdMap() {
+ if (!isset($this->idMapPlugin)) {
+ $configuration = $this->idMap;
+ $plugin = isset($configuration['plugin']) ? $configuration['plugin'] : 'sql';
+ $this->idMapPlugin = \Drupal::service('plugin.manager.migrate.id_map')->createInstance($plugin, $configuration, $this);
+ }
+ return $this->idMapPlugin;
+ }
+
+ /**
+ * @return \Drupal\Core\KeyValueStore\KeyValueStoreInterface
+ */
+ protected function getHighWaterStorage() {
+ if (!isset($this->highwaterStorage)) {
+ $this->highwaterStorage = \Drupal::keyValue('migrate:highwater');
+ }
+ return $this->highwaterStorage;
+ }
+
+ public function getHighwater() {
+ return $this->getHighWaterStorage()->get($this->id());
+ }
+
+ public function saveHighwater($highwater) {
+ $this->getHighWaterStorage()->set($this->id(), $highwater);
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Entity/MigrationInterface.php b/core/modules/migrate/lib/Drupal/migrate/Entity/MigrationInterface.php
new file mode 100644
index 000000000000..1fa3dad0ee7b
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Entity/MigrationInterface.php
@@ -0,0 +1,92 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Entity\MigrationInterface.
+ */
+
+namespace Drupal\migrate\Entity;
+
+use Drupal\Core\Config\Entity\ConfigEntityInterface;
+
+/**
+ * Interface for migrations.
+ */
+interface MigrationInterface extends ConfigEntityInterface {
+
+ const SOURCE = 'source';
+ const DESTINATION = 'destination';
+
+ /**
+ * Codes representing the current status of a migration, and stored in the
+ * migrate_status table.
+ */
+ const STATUS_IDLE = 0;
+ const STATUS_IMPORTING = 1;
+ const STATUS_ROLLING_BACK = 2;
+ const STATUS_STOPPING = 3;
+ const STATUS_DISABLED = 4;
+
+ /**
+ * Message types to be passed to saveMessage() and saved in message tables.
+ * MESSAGE_INFORMATIONAL represents a condition that did not prevent the
+ * operation from succeeding - all others represent different severities of
+ * conditions resulting in a source record not being imported.
+ */
+ const MESSAGE_ERROR = 1;
+ const MESSAGE_WARNING = 2;
+ const MESSAGE_NOTICE = 3;
+ const MESSAGE_INFORMATIONAL = 4;
+
+ /**
+ * Codes representing the result of a rollback or import process.
+ */
+ const RESULT_COMPLETED = 1; // All records have been processed
+ const RESULT_INCOMPLETE = 2; // The process has interrupted itself (e.g., the
+ // memory limit is approaching)
+ const RESULT_STOPPED = 3; // The process was stopped externally (e.g., via
+ // drush migrate-stop)
+ const RESULT_FAILED = 4; // The process had a fatal error
+ const RESULT_SKIPPED = 5; // Dependencies are unfulfilled - skip the process
+ const RESULT_DISABLED = 6; // This migration is disabled, skipping
+
+ /**
+ * Returns the initialized source plugin.
+ *
+ * @return \Drupal\migrate\Plugin\MigrateSourceInterface
+ */
+ public function getSourcePlugin();
+
+ /**
+ * Returns the process plugins.
+ *
+ * @param array $process
+ * A process configuration array.
+ *
+ * @return array
+ * A list of process plugins.
+ */
+ public function getProcessPlugins(array $process = NULL);
+
+ /**
+ * Returns the initialized destination plugin.
+ *
+ * @return \Drupal\migrate\Plugin\MigrateDestinationInterface
+ */
+ public function getDestinationPlugin();
+
+ /**
+ * Returns the initialized id_map plugin.
+ *
+ * @return \Drupal\migrate\Plugin\MigrateIdMapInterface
+ */
+ public function getIdMap();
+
+ /**
+ * @return int
+ */
+ public function getHighwater();
+
+ public function saveHighwater($highwater);
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/MigrateException.php b/core/modules/migrate/lib/Drupal/migrate/MigrateException.php
new file mode 100644
index 000000000000..d07c04f14eda
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/MigrateException.php
@@ -0,0 +1,75 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\MigrateException.
+ */
+
+namespace Drupal\migrate;
+
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+
+/**
+ * Defines the migrate exception class.
+ */
+class MigrateException extends \Exception {
+
+ /**
+ * The level of the error being reported.
+ *
+ * The value is a Migration::MESSAGE_* constant.
+ *
+ * @var int
+ */
+ protected $level;
+
+ /**
+ * The status to record in the map table for the current item.
+ *
+ * The value is a MigrateMap::STATUS_* constant.
+ *
+ * @var int
+ */
+ protected $status;
+
+ /**
+ * Constructs a MigrateException object.
+ *
+ * @param string $message
+ * The message for the exception.
+ * @param int $code
+ * The Exception code.
+ * @param \Exception $previous
+ * The previous exception used for the exception chaining.
+ * @param int $level
+ * The level of the error, a Migration::MESSAGE_* constant.
+ * @param int $status
+ * The status of the item for the map table, a MigrateMap::STATUS_*
+ * constant.
+ */
+ public function __construct($message = null, $code = 0, \Exception $previous = null, $level = MigrationInterface::MESSAGE_ERROR, $status = MigrateIdMapInterface::STATUS_FAILED) {
+ $this->level = $level;
+ $this->status = $status;
+ parent::__construct($message);
+ }
+
+ /**
+ * Gets the level.
+ *
+ * @return int
+ */
+ public function getLevel() {
+ return $this->level;
+ }
+
+ /**
+ * Gets the status of the current item.
+ *
+ * @return int
+ */
+ public function getStatus() {
+ return $this->status;
+ }
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/MigrateExecutable.php b/core/modules/migrate/lib/Drupal/migrate/MigrateExecutable.php
new file mode 100644
index 000000000000..9246ffec0ead
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/MigrateExecutable.php
@@ -0,0 +1,538 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\MigrateExecutable.
+ */
+
+namespace Drupal\migrate;
+
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+
+/**
+ * Defines a migrate executable class.
+ */
+class MigrateExecutable {
+
+ /**
+ * The migration to do.
+ *
+ * @var \Drupal\migrate\Entity\MigrationInterface
+ */
+ protected $migration;
+
+ /**
+ * The number of successfully imported rows since feedback was given.
+ *
+ * @var int
+ */
+ protected $successes_since_feedback;
+
+ /**
+ * The number of rows that were successfully processed.
+ *
+ * @var int
+ */
+ protected $total_successes;
+
+ /**
+ * Status of one row.
+ *
+ * The value is a MigrateIdMapInterface::STATUS_* constant, for example:
+ * STATUS_IMPORTED.
+ *
+ * @var int
+ */
+ protected $needsUpdate;
+
+ /**
+ * The number of rows processed.
+ *
+ * The total attempted, whether or not they were successful.
+ *
+ * @var int
+ */
+ protected $total_processed;
+
+ /**
+ * The queued messages not yet saved.
+ *
+ * Each element in the array is an array with two keys:
+ * - 'message': The message string.
+ * - 'level': The level, a MigrationInterface::MESSAGE_* constant.
+ *
+ * @var array
+ */
+ protected $queuedMessages = array();
+
+ /**
+ * The options that can be set when executing the migration.
+ *
+ * Values can be set for:
+ * - 'limit': Sets a time limit.
+ *
+ * @var array
+ */
+ protected $options;
+
+ /**
+ * The fraction of the memory limit at which an operation will be interrupted.
+ * Can be overridden by a Migration subclass if one would like to push the
+ * envelope. Defaults to 85%.
+ *
+ * @var float
+ */
+ protected $memoryThreshold = 0.85;
+
+ /**
+ * The PHP memory_limit expressed in bytes.
+ *
+ * @var int
+ */
+ protected $memoryLimit;
+
+ /**
+ * The fraction of the time limit at which an operation will be interrupted.
+ * Can be overridden by a Migration subclass if one would like to push the
+ * envelope. Defaults to 90%.
+ *
+ * @var float
+ */
+ protected $timeThreshold = 0.90;
+
+ /**
+ * The PHP max_execution_time.
+ *
+ * @var int
+ */
+ protected $timeLimit;
+
+ /**
+ * @var array
+ */
+ protected $sourceIdValues;
+
+ /**
+ * @var int
+ */
+ protected $processed_since_feedback = 0;
+
+ /**
+ * The translation manager.
+ *
+ * @var \Drupal\Core\StringTranslation\TranslationInterface
+ */
+ protected $translationManager;
+
+ /**
+ * @param MigrationInterface $migration
+ * @param MigrateMessageInterface $message
+ *
+ * @throws \Drupal\migrate\MigrateException
+ */
+ public function __construct(MigrationInterface $migration, MigrateMessageInterface $message) {
+ $this->migration = $migration;
+ $this->message = $message;
+ $this->migration->getIdMap()->setMessage($message);
+ // Record the memory limit in bytes
+ $limit = trim(ini_get('memory_limit'));
+ if ($limit == '-1') {
+ $this->memoryLimit = PHP_INT_MAX;
+ }
+ else {
+ if (!is_numeric($limit)) {
+ $last = strtolower(substr($limit, -1));
+ switch ($last) {
+ case 'g':
+ $limit *= 1024;
+ case 'm':
+ $limit *= 1024;
+ case 'k':
+ $limit *= 1024;
+ break;
+ default:
+ throw new MigrateException($this->t('Invalid PHP memory_limit !limit',
+ array('!limit' => $limit)));
+ }
+ }
+ $this->memoryLimit = $limit;
+ }
+ }
+
+ /**
+ * @return \Drupal\migrate\Source
+ */
+ public function getSource() {
+ if (!isset($this->source)) {
+ $this->source = new Source($this->migration, $this);
+ }
+ return $this->source;
+ }
+
+ /**
+ * The rollback action to be saved for the current row.
+ *
+ * @var int
+ */
+ public $rollbackAction;
+
+ /**
+ * An array of counts. Initially used for cache hit/miss tracking.
+ *
+ * @var array
+ */
+ protected $counts = array();
+
+ /**
+ * When performing a bulkRollback(), the maximum number of items to pass in
+ * a single call. Can be overridden in derived class constructor.
+ *
+ * @var int
+ */
+ protected $rollbackBatchSize = 50;
+
+ /**
+ * The object currently being constructed
+ * @var \stdClass
+ */
+ protected $destinationValues;
+
+ /**
+ * The current data row retrieved from the source.
+ * @var \stdClass
+ */
+ protected $sourceValues;
+
+ /**
+ * Perform an import operation - migrate items from source to destination.
+ */
+ public function import() {
+ $return = MigrationInterface::RESULT_COMPLETED;
+ $source = $this->getSource();
+ $destination = $this->migration->getDestinationPlugin();
+ $id_map = $this->migration->getIdMap();
+
+ try {
+ $source->rewind();
+ }
+ catch (\Exception $e) {
+ $this->message->display(
+ $this->t('Migration failed with source plugin exception: !e',
+ array('!e' => $e->getMessage())));
+ return MigrationInterface::RESULT_FAILED;
+ }
+ while ($source->valid()) {
+ $row = $source->current();
+ if ($this->sourceIdValues = $row->getSourceIdValues()) {
+ // Wipe old messages, and save any new messages.
+ $id_map->delete($row->getSourceIdValues(), TRUE);
+ $this->saveQueuedMessages();
+ }
+
+ $this->processRow($row);
+
+ try {
+ $destination_id_values = $destination->import($row);
+ // @TODO handle the successful but no ID case like config.
+ if ($destination_id_values) {
+ $id_map->saveIdMapping($row, $destination_id_values, $this->needsUpdate, $this->rollbackAction);
+ $this->successes_since_feedback++;
+ $this->total_successes++;
+ }
+ else {
+ $id_map->saveIdMapping($row, array(), MigrateIdMapInterface::STATUS_FAILED, $this->rollbackAction);
+ if ($id_map->messageCount() == 0) {
+ $message = $this->t('New object was not saved, no error provided');
+ $this->saveMessage($message);
+ $this->message->display($message);
+ }
+ }
+ }
+ catch (MigrateException $e) {
+ $this->migration->getIdMap()->saveIdMapping($row, array(), $e->getStatus(), $this->rollbackAction);
+ $this->saveMessage($e->getMessage(), $e->getLevel());
+ $this->message->display($e->getMessage());
+ }
+ catch (\Exception $e) {
+ $this->migration->getIdMap()->saveIdMapping($row, array(), MigrateIdMapInterface::STATUS_FAILED, $this->rollbackAction);
+ $this->handleException($e);
+ }
+ $this->total_processed++;
+ $this->processed_since_feedback++;
+ if ($highwater_property = $this->migration->get('highwaterProperty')) {
+ $this->migration->saveHighwater($row->getSourceProperty($highwater_property['name']));
+ }
+
+ // Reset row properties.
+ unset($sourceValues, $destinationValues);
+ $this->needsUpdate = MigrateIdMapInterface::STATUS_IMPORTED;
+
+ // TODO: Temporary. Remove when http://drupal.org/node/375494 is committed.
+ // TODO: Should be done in MigrateDestinationEntity
+ if (!empty($destination->entityType)) {
+ entity_get_controller($destination->entityType)->resetCache();
+ }
+
+ if (($return = $this->checkStatus()) != MigrationInterface::RESULT_COMPLETED) {
+ break;
+ }
+ if ($this->timeOptionExceeded()) {
+ break;
+ }
+ try {
+ $source->next();
+ }
+ catch (\Exception $e) {
+ $this->message->display(
+ $this->t('Migration failed with source plugin exception: !e',
+ array('!e' => $e->getMessage())));
+ return MigrationInterface::RESULT_FAILED;
+ }
+ }
+
+ /**
+ * @TODO uncomment this
+ */
+ #$this->progressMessage($return);
+
+ return $return;
+ }
+
+ /**
+ * @param Row $row
+ * The $row to be processed.
+ * @param array $process
+ * A process pipeline configuration. If not set, the top level process
+ * configuration in the migration entity is used.
+ * @param mixed $value
+ * Optional initial value of the pipeline for the first destination.
+ * Usually setting this is not necessary as $process typically starts with
+ * a 'get'. This is useful only when the $process contains a single
+ * destination and needs to access a value outside of the source. See
+ * \Drupal\migrate\Plugin\migrate\process\Iterator::transformKey for an
+ * example.
+ */
+ public function processRow(Row $row, array $process = NULL, $value = NULL) {
+ foreach ($this->migration->getProcessPlugins($process) as $destination => $plugins) {
+ foreach ($plugins as $plugin) {
+ $value = $plugin->transform($value, $this, $row, $destination);
+ }
+ $row->setDestinationProperty($destination, $value);
+ // Reset the value.
+ $value = NULL;
+ }
+ }
+
+ /**
+ * Fetch the key array for the current source record.
+ *
+ * @return array
+ */
+ protected function currentSourceIds() {
+ return $this->getSource()->getCurrentIds();
+ }
+
+ /**
+ * Test whether we've exceeded the designated time limit.
+ *
+ * @return boolean
+ * TRUE if the threshold is exceeded, FALSE if not.
+ */
+ protected function timeOptionExceeded() {
+ if (!$time_limit = $this->getTimeLimit()) {
+ return FALSE;
+ }
+ $time_elapsed = time() - REQUEST_TIME;
+ if ($time_elapsed >= $time_limit) {
+ return TRUE;
+ }
+ else {
+ return FALSE;
+ }
+ }
+
+ public function getTimeLimit() {
+ if (isset($this->options['limit']) &&
+ ($this->options['limit']['unit'] == 'seconds' || $this->options['limit']['unit'] == 'second')) {
+ return $this->options['limit']['value'];
+ }
+ else {
+ return NULL;
+ }
+ }
+
+ /**
+ * Pass messages through to the map class.
+ *
+ * @param string $message
+ * The message to record.
+ * @param int $level
+ * Optional message severity (defaults to MESSAGE_ERROR).
+ */
+ public function saveMessage($message, $level = MigrationInterface::MESSAGE_ERROR) {
+ $this->migration->getIdMap()->saveMessage($this->sourceIdValues, $message, $level);
+ }
+
+ /**
+ * Queue messages to be later saved through the map class.
+ *
+ * @param string $message
+ * The message to record.
+ * @param int $level
+ * Optional message severity (defaults to MESSAGE_ERROR).
+ */
+ public function queueMessage($message, $level = MigrationInterface::MESSAGE_ERROR) {
+ $this->queuedMessages[] = array('message' => $message, 'level' => $level);
+ }
+
+ /**
+ * Save any messages we've queued up to the message table.
+ */
+ public function saveQueuedMessages() {
+ foreach ($this->queuedMessages as $queued_message) {
+ $this->saveMessage($queued_message['message'], $queued_message['level']);
+ }
+ $this->queuedMessages = array();
+ }
+
+ /**
+ * Standard top-of-loop stuff, common between rollback and import - check
+ * for exceptional conditions, and display feedback.
+ */
+ protected function checkStatus() {
+ if ($this->memoryExceeded()) {
+ return MigrationInterface::RESULT_INCOMPLETE;
+ }
+ if ($this->timeExceeded()) {
+ return MigrationInterface::RESULT_INCOMPLETE;
+ }
+ /*
+ * @TODO uncomment this
+ if ($this->getStatus() == MigrationInterface::STATUS_STOPPING) {
+ return MigrationBase::RESULT_STOPPED;
+ }
+ */
+ // If feedback is requested, produce a progress message at the proper time
+ /*
+ * @TODO uncomment this
+ if (isset($this->feedback)) {
+ if (($this->feedback_unit == 'seconds' && time() - $this->lastfeedback >= $this->feedback) ||
+ ($this->feedback_unit == 'items' && $this->processed_since_feedback >= $this->feedback)) {
+ $this->progressMessage(MigrationInterface::RESULT_INCOMPLETE);
+ }
+ }
+ */
+
+ return MigrationInterface::RESULT_COMPLETED;
+ }
+
+ /**
+ * Test whether we've exceeded the desired memory threshold. If so, output a message.
+ *
+ * @return boolean
+ * TRUE if the threshold is exceeded, FALSE if not.
+ */
+ protected function memoryExceeded() {
+ $usage = memory_get_usage();
+ $pct_memory = $usage / $this->memoryLimit;
+ if ($pct_memory > $this->memoryThreshold) {
+ $this->message->display(
+ $this->t('Memory usage is !usage (!pct% of limit !limit), resetting statics',
+ array('!pct' => round($pct_memory*100),
+ '!usage' => format_size($usage),
+ '!limit' => format_size($this->memoryLimit))),
+ 'warning');
+ // First, try resetting Drupal's static storage - this frequently releases
+ // plenty of memory to continue
+ drupal_static_reset();
+ $usage = memory_get_usage();
+ $pct_memory = $usage/$this->memoryLimit;
+ // Use a lower threshold - we don't want to be in a situation where we keep
+ // coming back here and trimming a tiny amount
+ if ($pct_memory > (.90 * $this->memoryThreshold)) {
+ $this->message->display(
+ $this->t('Memory usage is now !usage (!pct% of limit !limit), not enough reclaimed, starting new batch',
+ array('!pct' => round($pct_memory*100),
+ '!usage' => format_size($usage),
+ '!limit' => format_size($this->memoryLimit))),
+ 'warning');
+ return TRUE;
+ }
+ else {
+ $this->message->display(
+ $this->t('Memory usage is now !usage (!pct% of limit !limit), reclaimed enough, continuing',
+ array('!pct' => round($pct_memory*100),
+ '!usage' => format_size($usage),
+ '!limit' => format_size($this->memoryLimit))),
+ 'warning');
+ return FALSE;
+ }
+ }
+ else {
+ return FALSE;
+ }
+ }
+
+ /**
+ * Test whether we're approaching the PHP time limit.
+ *
+ * @return boolean
+ * TRUE if the threshold is exceeded, FALSE if not.
+ */
+ protected function timeExceeded() {
+ if ($this->timeLimit == 0) {
+ return FALSE;
+ }
+ $time_elapsed = time() - REQUEST_TIME;
+ $pct_time = $time_elapsed / $this->timeLimit;
+ if ($pct_time > $this->timeThreshold) {
+ return TRUE;
+ }
+ else {
+ return FALSE;
+ }
+ }
+
+ /**
+ * Takes an Exception object and both saves and displays it, pulling additional
+ * information on the location triggering the exception.
+ *
+ * @param \Exception $exception
+ * Object representing the exception.
+ * @param boolean $save
+ * Whether to save the message in the migration's mapping table. Set to FALSE
+ * in contexts where this doesn't make sense.
+ */
+ public function handleException($exception, $save = TRUE) {
+ $result = _drupal_decode_exception($exception);
+ $message = $result['!message'] . ' (' . $result['%file'] . ':' . $result['%line'] . ')';
+ if ($save) {
+ $this->saveMessage($message);
+ }
+ $this->message->display($message);
+ }
+
+ /**
+ * Translates a string to the current language or to a given language.
+ *
+ * See the t() documentation for details.
+ */
+ protected function t($string, array $args = array(), array $options = array()) {
+ return $this->translationManager()->translate($string, $args, $options);
+ }
+
+ /**
+ * Gets the translation manager.
+ *
+ * @return \Drupal\Core\StringTranslation\TranslationInterface
+ * The translation manager.
+ */
+ protected function translationManager() {
+ if (!$this->translationManager) {
+ $this->translationManager = \Drupal::translation();
+ }
+ return $this->translationManager;
+ }
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/MigrateMessage.php b/core/modules/migrate/lib/Drupal/migrate/MigrateMessage.php
new file mode 100644
index 000000000000..d90297e095d5
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/MigrateMessage.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\MigrateMessage.
+ */
+
+namespace Drupal\migrate;
+
+/**
+ * Defines a migrate message class.
+ */
+class MigrateMessage implements MigrateMessageInterface {
+
+ /**
+ * Displays a migrate message.
+ *
+ * @param string $message
+ * The message to display.
+ * @param string $type
+ * The type of message, for example: status or warning.
+ */
+ function display($message, $type = 'status') {
+ drupal_set_message($message, $type);
+ }
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/MigrateMessageInterface.php b/core/modules/migrate/lib/Drupal/migrate/MigrateMessageInterface.php
new file mode 100644
index 000000000000..bcf3753f9201
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/MigrateMessageInterface.php
@@ -0,0 +1,19 @@
+<?php
+/**
+ * @file
+ * Contains
+ */
+
+namespace Drupal\migrate;
+
+
+interface MigrateMessageInterface {
+
+ /**
+ * @param $message
+ * @param string $type
+ *
+ * @return mixed
+ */
+ function display($message, $type = 'status');
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateDestinationInterface.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateDestinationInterface.php
new file mode 100644
index 000000000000..97ede97e77fb
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateDestinationInterface.php
@@ -0,0 +1,63 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\MigrateDestinationInterface.
+ */
+
+namespace Drupal\migrate\Plugin;
+
+use Drupal\Component\Plugin\PluginInspectionInterface;
+use Drupal\migrate\Entity\Migration;
+use Drupal\migrate\Row;
+
+/**
+ * Destinations are responsible for persisting source data into the destination
+ * Drupal.
+ */
+interface MigrateDestinationInterface extends PluginInspectionInterface {
+
+ /**
+ * To support MigrateIdMap maps, derived destination classes should return
+ * schema field definition(s) corresponding to the primary key of the destination
+ * being implemented. These are used to construct the destination key fields
+ * of the map table for a migration using this destination.
+ */
+ public function getIdsSchema();
+
+ /**
+ * Derived classes must implement fields(), returning a list of available
+ * destination fields.
+ *
+ * @todo Review the cases where we need the Migration parameter, can we avoid that?
+ *
+ * @param Migration $migration
+ * Optionally, the migration containing this destination.
+ * @return array
+ * - Keys: machine names of the fields
+ * - Values: Human-friendly descriptions of the fields.
+ */
+ public function fields(Migration $migration = NULL);
+
+ /**
+ * Derived classes may implement preImport() and/or postImport(), to do any
+ * processing they need done before or after looping over all source rows.
+ * Similarly, preRollback() or postRollback() may be implemented.
+ */
+ public function preImport();
+ public function preRollback();
+ public function postImport();
+ public function postRollback();
+
+ /**
+ * Derived classes must implement import(), to construct one new object (pre-populated
+ * using ID mappings in the Migration).
+ */
+ public function import(Row $row);
+
+ /**
+ * Delete the specified IDs from the target Drupal.
+ * @param array $destination_identifiers
+ */
+ public function rollbackMultiple(array $destination_identifiers);
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateIdMapInterface.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateIdMapInterface.php
new file mode 100644
index 000000000000..53c6ff5a3b85
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateIdMapInterface.php
@@ -0,0 +1,241 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\MigrateIdMapInterface.
+ */
+
+namespace Drupal\migrate\Plugin;
+
+use Drupal\Component\Plugin\PluginInspectionInterface;
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\MigrateMessageInterface;
+use Drupal\migrate\Row;
+
+/**
+ * Defines an interface for migrate ID mappings.
+ *
+ * Migrate ID mappings maintain a relation between source ID and destination ID
+ * for audit and rollback purposes.
+ */
+interface MigrateIdMapInterface extends PluginInspectionInterface {
+
+ /**
+ * Codes reflecting the current status of a map row.
+ */
+ const STATUS_IMPORTED = 0;
+ const STATUS_NEEDS_UPDATE = 1;
+ const STATUS_IGNORED = 2;
+ const STATUS_FAILED = 3;
+
+ /**
+ * Codes reflecting how to handle the destination item on rollback.
+ */
+ const ROLLBACK_DELETE = 0;
+ const ROLLBACK_PRESERVE = 1;
+
+ /**
+ * Saves a mapping from the source identifiers to the destination identifiers.
+ *
+ * Called upon import of one row, we record a mapping from the source ID
+ * to the destination ID. Also may be called, setting the third parameter to
+ * NEEDS_UPDATE, to signal an existing record should be re-migrated.
+ *
+ * @param \Drupal\migrate\Row $row
+ * The raw source data. We use the ID map derived from the source object
+ * to get the source identifier values.
+ * @param array $destination_id_values
+ * An array of destination identifier values.
+ * @param int $status
+ * Status of the source row in the map.
+ * @param int $rollback_action
+ * How to handle the destination object on rollback.
+ */
+ public function saveIdMapping(Row $row, array $destination_id_values, $status = self::STATUS_IMPORTED, $rollback_action = self::ROLLBACK_DELETE);
+
+ /**
+ * Saves a message related to a source record in the migration message table.
+ *
+ * @param array $source_id_values
+ * The source identifier values of the record in error.
+ * @param string $message
+ * The message to record.
+ * @param int $level
+ * Optional message severity (defaults to MESSAGE_ERROR).
+ */
+ public function saveMessage(array $source_id_values, $message, $level = MigrationInterface::MESSAGE_ERROR);
+
+ /**
+ * Prepares to run a full update.
+ *
+ * Prepares this migration to run as an update - that is, in addition to
+ * unmigrated content (source records not in the map table) being imported,
+ * previously-migrated content will also be updated in place by marking all
+ * previously-imported content as ready to be re-imported.
+ */
+ public function prepareUpdate();
+
+ /**
+ * Returns the number of processed items in the map.
+ *
+ * @return int
+ * The count of records in the map table.
+ */
+ public function processedCount();
+
+ /**
+ * Returns the number of imported items in the map.
+ *
+ * @return int
+ * The number of imported items.
+ */
+ public function importedCount();
+
+
+ /**
+ * Returns a count of items which are marked as needing update.
+ *
+ * @return int
+ * The number of items which need updating.
+ */
+ public function updateCount();
+
+ /**
+ * Returns the number of items that failed to import.
+ *
+ * @return int
+ * The number of items that errored out.
+ */
+ public function errorCount();
+
+ /**
+ * Returns the number of messages saved.
+ *
+ * @return int
+ * The number of messages.
+ */
+ public function messageCount();
+
+ /**
+ * Deletes the map and message entries for a given source record.
+ *
+ * @param array $source_id_values
+ * The source identifier values of the record to delete.
+ * @param bool $messages_only
+ * TRUE to only delete the migrate messages.
+ */
+ public function delete(array $source_id_values, $messages_only = FALSE);
+
+ /**
+ * Deletes the map and message table entries for a given destination row.
+ *
+ * @param array $destination_id_values
+ * The destination identifier values we should do the deletes for.
+ */
+ public function deleteDestination(array $destination_id_values);
+
+ /**
+ * Deletes the map and message entries for a set of given source records.
+ *
+ * @param array $source_id_values
+ * The identifier values of the sources we should do the deletes for. Each
+ * array member is an array of identifier values for one source row.
+ */
+ public function deleteBulk(array $source_id_values);
+
+ /**
+ * Clears all messages from the map.
+ */
+ public function clearMessages();
+
+ /**
+ * Retrieves a row from the map table based on source identifier values.
+ *
+ * @param array $source_id_values
+ * The source identifier values of the record to retrieve.
+ *
+ * @return array
+ * The raw row data as an associative array.
+ */
+ public function getRowBySource(array $source_id_values);
+
+ /**
+ * Retrieves a row by the destination identifiers.
+ *
+ * @param array $destination_id_values
+ * The destination identifier values of the record to retrieve.
+ *
+ * @return array
+ * The row(s) of data.
+ */
+ public function getRowByDestination(array $destination_id_values);
+
+ /**
+ * Retrieves an array of map rows marked as needing update.
+ *
+ * @param int $count
+ * The maximum number of rows to return.
+ *
+ * @return array
+ * Array of map row objects that need updating.
+ */
+ public function getRowsNeedingUpdate($count);
+
+ /**
+ * Looks up the source identifier.
+ *
+ * Given a (possibly multi-field) destination identifier value, return the
+ * (possibly multi-field) source identifier value mapped to it.
+ *
+ * @param array $destination_id_values
+ * The destination identifier values of the record.
+ *
+ * @return array
+ * The source identifier values of the record, or NULL on failure.
+ */
+ public function lookupSourceID(array $destination_id_values);
+
+ /**
+ * Looks up the destination identifier.
+ *
+ * Given a (possibly multi-field) source identifier value, return the
+ * (possibly multi-field) destination identifier value it is mapped to.
+ *
+ * @param array $destination_id_values
+ * The source identifier values of the record.
+ *
+ * @return array
+ * The destination identifier values of the record, or NULL on failure.
+ */
+ public function lookupDestinationID(array $source_id_values);
+
+ /**
+ * Removes any persistent storage used by this map.
+ *
+ * For example, remove the map and message tables.
+ */
+ public function destroy();
+
+ /**
+ * Gets the qualified map table.
+ *
+ * @todo Remove this as this is SQL only and so doesn't belong to the interface.
+ */
+ public function getQualifiedMapTable();
+
+ /**
+ * Sets the migrate message.
+ *
+ * @param \Drupal\migrate\MigrateMessageInterface $message
+ * The message to display.
+ */
+ public function setMessage(MigrateMessageInterface $message);
+
+ /**
+ * Sets a specified record to be updated, if it exists.
+ *
+ * @param $source_id_values
+ * The source identifier values of the record.
+ */
+ public function setUpdate(array $source_id_values);
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/MigratePluginManager.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigratePluginManager.php
new file mode 100644
index 000000000000..a67b86e5afd2
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigratePluginManager.php
@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\MigraterPluginManager.
+ */
+
+namespace Drupal\migrate\Plugin;
+
+use Drupal\Component\Plugin\Factory\DefaultFactory;
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\Language\LanguageManager;
+use Drupal\Core\Plugin\DefaultPluginManager;
+use Drupal\migrate\Entity\MigrationInterface;
+
+/**
+ * Manages migrate sources and steps.
+ *
+ * @see hook_migrate_info_alter()
+ */
+class MigratePluginManager extends DefaultPluginManager {
+
+ /**
+ * Constructs a MigraterPluginManager object.
+ *
+ * @param string $type
+ * The type of the plugin: row, source, process, destination, entity_field, id_map.
+ * @param \Traversable $namespaces
+ * An object that implements \Traversable which contains the root paths
+ * keyed by the corresponding namespace to look for plugin implementations.
+ * @param \Drupal\Core\Cache\CacheBackendInterface $cache_backend
+ * Cache backend instance to use.
+ * @param \Drupal\Core\Language\LanguageManager $language_manager
+ * The language manager.
+ * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+ * The module handler to invoke the alter hook with.
+ */
+ public function __construct($type, \Traversable $namespaces, CacheBackendInterface $cache_backend, LanguageManager $language_manager, ModuleHandlerInterface $module_handler) {
+ parent::__construct("Plugin/migrate/$type", $namespaces, 'Drupal\Component\Annotation\PluginID');
+ $this->alterInfo($module_handler, 'migrate_' . $type . '_info');
+ $this->setCacheBackend($cache_backend, $language_manager, 'migrate_plugins_' . $type);
+ }
+
+ /**
+ * {@inheritdoc}
+ *
+ * A specific createInstance method is necessary to pass the migration on.
+ */
+ public function createInstance($plugin_id, array $configuration = array(), MigrationInterface $migration = NULL) {
+ $plugin_definition = $this->discovery->getDefinition($plugin_id);
+ $plugin_class = DefaultFactory::getPluginClass($plugin_id, $plugin_definition);
+ // If the plugin provides a factory method, pass the container to it.
+ if (is_subclass_of($plugin_class, 'Drupal\Core\Plugin\ContainerFactoryPluginInterface')) {
+ return $plugin_class::create(\Drupal::getContainer(), $configuration, $plugin_id, $plugin_definition, $migration);
+ }
+ return new $plugin_class($configuration, $plugin_id, $plugin_definition, $migration);
+ }
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateProcessInterface.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateProcessInterface.php
new file mode 100644
index 000000000000..74da65265cbc
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateProcessInterface.php
@@ -0,0 +1,36 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\MigrateProcessInterface.
+ */
+
+namespace Drupal\migrate\Plugin;
+
+use Drupal\Component\Plugin\PluginInspectionInterface;
+use Drupal\migrate\MigrateExecutable;
+use Drupal\migrate\Row;
+
+/**
+ * An interface for migrate processes.
+ */
+interface MigrateProcessInterface extends PluginInspectionInterface {
+
+ /**
+ * Performs the associated process.
+ *
+ * @param $value
+ * The value to be transformed.
+ * @param \Drupal\migrate\MigrateExecutable $migrate_executable
+ * The migration in which this process is being executed.
+ * @param \Drupal\migrate\Row $row
+ * The row from the source to process. Normally, just transforming the
+ * value is adequate but very rarely you might need to change two columns
+ * at the same time or something like that.
+ * @param string $destination_property
+ * The destination property currently worked on. This is only used
+ * together with the $row above.
+ */
+ public function transform($value, MigrateExecutable $migrate_executable, Row $row, $destination_property);
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateSourceInterface.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateSourceInterface.php
new file mode 100644
index 000000000000..9b9b9821750a
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/MigrateSourceInterface.php
@@ -0,0 +1,45 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\MigrateSourceInterface.
+ */
+
+namespace Drupal\migrate\Plugin;
+use Drupal\Component\Plugin\PluginInspectionInterface;
+use Drupal\migrate\Row;
+
+/**
+ * Defines an interface for migrate sources.
+ */
+interface MigrateSourceInterface extends \Countable, PluginInspectionInterface {
+
+ /**
+ * Returns available fields on the source.
+ *
+ * @return array
+ * Available fields in the source, keys are the field machine names as used
+ * in field mappings, values are descriptions.
+ */
+ public function fields();
+
+
+ /**
+ * Returns the iterator that will yield the row arrays to be processed.
+ *
+ * @return \Iterator
+ */
+ public function getIterator();
+
+ /**
+ * Add additional data to the row.
+ *
+ * @param \Drupal\Migrate\Row $row
+ *
+ * @return bool
+ * FALSE if this row needs to be skipped.
+ */
+ public function prepareRow(Row $row);
+
+ public function __toString();
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/RequirementsInterface.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/RequirementsInterface.php
new file mode 100644
index 000000000000..ad45be5ac197
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/RequirementsInterface.php
@@ -0,0 +1,23 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\RequirementsInterface.
+ */
+
+namespace Drupal\migrate\Plugin;
+
+/**
+ * An interface to check for a migrate plugin requirements.
+ */
+interface RequirementsInterface {
+
+ /**
+ * Checks if requirements for this plugin are OK.
+ *
+ * @return boolean
+ * TRUE if it is possible to use the plugin, FALSE if not.
+ */
+ public function checkRequirements();
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/destination/Config.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/destination/Config.php
new file mode 100644
index 000000000000..36ead846fe0a
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/destination/Config.php
@@ -0,0 +1,87 @@
+<?php
+/**
+ * @file
+ * Provides Configuration Management destination plugin.
+ */
+
+namespace Drupal\migrate\Plugin\migrate\destination;
+
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\migrate\Entity\Migration;
+use Drupal\migrate\MigrateException;
+use Drupal\migrate\Row;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+use Drupal\Core\Config\Config as ConfigObject;
+
+/**
+ * Persist data to the config system.
+ *
+ * @PluginID("d8_config")
+ */
+class Config extends DestinationBase implements ContainerFactoryPluginInterface {
+
+ /**
+ * The config object.
+ *
+ * @var \Drupal\Core\Config\Config
+ */
+ protected $config;
+
+ /**
+ * @param array $configuration
+ * @param string $plugin_id
+ * @param array $plugin_definition
+ * @param ConfigObject $config
+ */
+ public function __construct(array $configuration, $plugin_id, array $plugin_definition, ConfigObject $config) {
+ parent::__construct($configuration, $plugin_id, $plugin_definition);
+ $this->config = $config;
+ }
+
+ public static function create(ContainerInterface $container, array $configuration, $plugin_id, array $plugin_definition) {
+ return new static(
+ $configuration,
+ $plugin_id,
+ $plugin_definition,
+ $container->get('config.factory')->get($configuration['config_name'])
+ );
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function import(Row $row) {
+ $this->config
+ ->setData($row->getDestination())
+ ->save();
+ }
+
+ /**
+ * @param array $destination_keys
+ *
+ * @throws \Drupal\migrate\MigrateException
+ */
+ public function rollbackMultiple(array $destination_keys) {
+ throw new MigrateException('Configuration can not be rolled back');
+ }
+
+ /**
+ * Derived classes must implement fields(), returning a list of available
+ * destination fields.
+ *
+ * @todo Review the cases where we need the Migration parameter, can we avoid that?
+ *
+ * @param Migration $migration
+ * Optionally, the migration containing this destination.
+ * @return array
+ * - Keys: machine names of the fields
+ * - Values: Human-friendly descriptions of the fields.
+ */
+ public function fields(Migration $migration = NULL) {
+ // @todo Dynamically fetch fields using Config Schema API.
+ }
+
+ public function getIdsSchema() {
+ return array($this->config->getName() => array());
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/destination/DestinationBase.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/destination/DestinationBase.php
new file mode 100644
index 000000000000..7cdf11b69020
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/destination/DestinationBase.php
@@ -0,0 +1,53 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\migrate\destination\DestinationBase.
+ */
+
+
+namespace Drupal\migrate\Plugin\migrate\destination;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\migrate\Plugin\MigrateDestinationInterface;
+
+abstract class DestinationBase extends PluginBase implements MigrateDestinationInterface {
+
+ /**
+ * Modify the Row before it is imported.
+ */
+ public function preImport() {
+ // TODO: Implement preImport() method.
+ }
+
+ /**
+ * Modify the Row before it is rolled back.
+ */
+ public function preRollback() {
+ // TODO: Implement preRollback() method.
+ }
+
+ public function postImport() {
+ // TODO: Implement postImport() method.
+ }
+
+ public function postRollback() {
+ // TODO: Implement postRollback() method.
+ }
+
+ public function rollbackMultiple(array $destination_identifiers) {
+ // TODO: Implement rollbackMultiple() method.
+ }
+
+ public function getCreated() {
+ // TODO: Implement getCreated() method.
+ }
+
+ public function getUpdated() {
+ // TODO: Implement getUpdated() method.
+ }
+
+ public function resetStats() {
+ // TODO: Implement resetStats() method.
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/id_map/Sql.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/id_map/Sql.php
new file mode 100644
index 000000000000..02ad801267dc
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/id_map/Sql.php
@@ -0,0 +1,705 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\migrate\id_map\Sql.
+ */
+
+namespace Drupal\migrate\Plugin\migrate\id_map;
+
+use Drupal\Component\Utility\Unicode;
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\MigrateException;
+use Drupal\migrate\MigrateMessageInterface;
+use Drupal\migrate\Plugin\migrate\source\SqlBase;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+use Drupal\migrate\Row;
+
+/**
+ * Defines the sql based ID map implementation.
+ *
+ * It creates one map and one message table per migration entity to store the
+ * relevant information.
+ *
+ * @PluginID("sql")
+ */
+class Sql extends PluginBase implements MigrateIdMapInterface {
+
+ /**
+ * Names of tables created for tracking the migration.
+ *
+ * @var string
+ */
+ protected $mapTable, $messageTable;
+
+ /**
+ * The migrate message.
+ *
+ * @var \Drupal\migrate\MigrateMessageInterface
+ */
+ protected $message;
+
+ /**
+ * The database connection for the map/message tables on the destination.
+ *
+ * @var \Drupal\Core\Database\Connection
+ */
+ protected $database;
+
+ /**
+ * @var \Drupal\Core\Database\Query\SelectInterface
+ */
+ protected $query;
+
+ /**
+ * The migration being done.
+ *
+ * @var \Drupal\migrate\Entity\MigrationInterface
+ */
+ protected $migration;
+
+ /**
+ * The source ID fields.
+ *
+ * @var array
+ */
+ protected $sourceIdFields;
+
+ /**
+ * The destination ID fields.
+ *
+ * @var array
+ */
+ protected $destinationIdFields;
+
+ /**
+ * Stores whether the the tables (map/message) already exist.
+ *
+ * This is determined just once per request/instance of the class.
+ *
+ * @var boolean
+ */
+ protected $ensured;
+
+ /**
+ * The result.
+ *
+ * @var null
+ */
+ protected $result = NULL;
+
+ /**
+ * The current row.
+ *
+ * @var null
+ */
+ protected $currentRow = NULL;
+
+ /**
+ * The current key.
+ *
+ * @var array
+ */
+ protected $currentKey = array();
+
+ /**
+ * Constructs an SQL object.
+ *
+ * Sets up the tables and builds the maps,
+ *
+ * @param array $configuration
+ * The configuration.
+ * @param string $plugin_id
+ * The plugin ID for the migration process to do.
+ * @param array $plugin_definition
+ * The configuration for the plugin.
+ * @param \Drupal\migrate\Entity\MigrationInterface $migration
+ * The migration to do.
+ */
+ public function __construct(array $configuration, $plugin_id, array $plugin_definition, MigrationInterface $migration) {
+ parent::__construct($configuration, $plugin_id, $plugin_definition);
+
+ $this->migration = $migration;
+ $machine_name = $migration->id();
+
+ // Default generated table names, limited to 63 characters.
+ $prefixLength = strlen($this->getDatabase()->tablePrefix()) ;
+ $this->mapTable = 'migrate_map_' . Unicode::strtolower($machine_name);
+ $this->mapTable = Unicode::substr($this->mapTable, 0, 63 - $prefixLength);
+ $this->messageTable = 'migrate_message_' . Unicode::strtolower($machine_name);
+ $this->messageTable = Unicode::substr($this->messageTable, 0, 63 - $prefixLength);
+ $this->sourceIds = $migration->get('sourceIds');
+ $this->destinationIds = $migration->get('destinationIds');
+
+ // Build the source and destination identifier maps.
+ $this->sourceIdFields = array();
+ $count = 1;
+ foreach ($this->sourceIds as $field => $schema) {
+ $this->sourceIdFields[$field] = 'sourceid' . $count++;
+ }
+ $this->destinationIdFields = array();
+ $count = 1;
+ foreach ($this->destinationIds as $field => $schema) {
+ $this->destinationIdFields[$field] = 'destid' . $count++;
+ }
+ $this->ensureTables();
+ }
+
+ /**
+ * Qualifying the map table name with the database name makes cross-db joins
+ * possible. Note that, because prefixes are applied after we do this (i.e.,
+ * it will prefix the string we return), we do not qualify the table if it has
+ * a prefix. This will work fine when the source data is in the default
+ * (prefixed) database (in particular, for simpletest), but not if the primary
+ * query is in an external database.
+ *
+ * @return string
+ */
+ public function getQualifiedMapTable() {
+ $options = $this->getDatabase()->getConnectionOptions();
+ $prefix = $this->getDatabase()->tablePrefix($this->mapTable);
+ if ($prefix) {
+ return $this->mapTable;
+ }
+ else {
+ return $options['database'] . '.' . $this->mapTable;
+ }
+ }
+
+ /**
+ * Gets the database connection.
+ *
+ * @return \Drupal\Core\Database\Connection
+ */
+ protected function getDatabase() {
+ if (!isset($this->database)) {
+ $this->database = SqlBase::getDatabaseConnection($this->migration->id(), $this->configuration);
+ }
+ return $this->database;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function setMessage(MigrateMessageInterface $message) {
+ $this->message = $message;
+ }
+
+ /**
+ * Create the map and message tables if they don't already exist.
+ */
+ protected function ensureTables() {
+ if (!$this->ensured) {
+ if (!$this->getDatabase()->schema()->tableExists($this->mapTable)) {
+ // Generate appropriate schema info for the map and message tables,
+ // and map from the source field names to the map/msg field names.
+ $count = 1;
+ $source_id_schema = array();
+ $pks = array();
+ foreach ($this->sourceIds as $field_schema) {
+ $mapkey = 'sourceid' . $count++;
+ $source_id_schema[$mapkey] = $field_schema;
+ $pks[] = $mapkey;
+ }
+
+ $fields = $source_id_schema;
+
+ // Add destination identifiers to map table.
+ // TODO: How do we discover the destination schema?
+ $count = 1;
+ foreach ($this->destinationIds as $field_schema) {
+ // Allow dest identifier fields to be NULL (for IGNORED/FAILED
+ // cases).
+ $field_schema['not null'] = FALSE;
+ $mapkey = 'destid' . $count++;
+ $fields[$mapkey] = $field_schema;
+ }
+ $fields['needs_update'] = array(
+ 'type' => 'int',
+ 'size' => 'tiny',
+ 'unsigned' => TRUE,
+ 'not null' => TRUE,
+ 'default' => MigrateIdMapInterface::STATUS_IMPORTED,
+ 'description' => 'Indicates current status of the source row',
+ );
+ $fields['rollback_action'] = array(
+ 'type' => 'int',
+ 'size' => 'tiny',
+ 'unsigned' => TRUE,
+ 'not null' => TRUE,
+ 'default' => MigrateIdMapInterface::ROLLBACK_DELETE,
+ 'description' => 'Flag indicating what to do for this item on rollback',
+ );
+ $fields['last_imported'] = array(
+ 'type' => 'int',
+ 'unsigned' => TRUE,
+ 'not null' => TRUE,
+ 'default' => 0,
+ 'description' => 'UNIX timestamp of the last time this row was imported',
+ );
+ $fields['hash'] = array(
+ 'type' => 'varchar',
+ 'length' => '32',
+ 'not null' => FALSE,
+ 'description' => 'Hash of source row data, for detecting changes',
+ );
+ $schema = array(
+ 'description' => 'Mappings from source identifier value(s) to destination identifier value(s).',
+ 'fields' => $fields,
+ );
+ if ($pks) {
+ $schema['primary key'] = $pks;
+ }
+ $this->getDatabase()->schema()->createTable($this->mapTable, $schema);
+
+ // Now do the message table.
+ $fields = array();
+ $fields['msgid'] = array(
+ 'type' => 'serial',
+ 'unsigned' => TRUE,
+ 'not null' => TRUE,
+ );
+ $fields += $source_id_schema;
+
+ $fields['level'] = array(
+ 'type' => 'int',
+ 'unsigned' => TRUE,
+ 'not null' => TRUE,
+ 'default' => 1,
+ );
+ $fields['message'] = array(
+ 'type' => 'text',
+ 'size' => 'medium',
+ 'not null' => TRUE,
+ );
+ $schema = array(
+ 'description' => 'Messages generated during a migration process',
+ 'fields' => $fields,
+ 'primary key' => array('msgid'),
+ );
+ if ($pks) {
+ $schema['indexes']['sourcekey'] = $pks;
+ }
+ $this->getDatabase()->schema()->createTable($this->messageTable, $schema);
+ }
+ else {
+ // Add any missing columns to the map table.
+ if (!$this->getDatabase()->schema()->fieldExists($this->mapTable,
+ 'rollback_action')) {
+ $this->getDatabase()->schema()->addField($this->mapTable,
+ 'rollback_action', array(
+ 'type' => 'int',
+ 'size' => 'tiny',
+ 'unsigned' => TRUE,
+ 'not null' => TRUE,
+ 'default' => 0,
+ 'description' => 'Flag indicating what to do for this item on rollback',
+ ));
+ }
+ if (!$this->getDatabase()->schema()->fieldExists($this->mapTable, 'hash')) {
+ $this->getDatabase()->schema()->addField($this->mapTable, 'hash', array(
+ 'type' => 'varchar',
+ 'length' => '32',
+ 'not null' => FALSE,
+ 'description' => 'Hash of source row data, for detecting changes',
+ ));
+ }
+ }
+ $this->ensured = TRUE;
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getRowBySource(array $source_id_value) {
+ $query = $this->getDatabase()->select($this->mapTable, 'map')
+ ->fields('map');
+ foreach ($this->sourceIdFields as $source_id) {
+ $query = $query->condition("map.$source_id", array_shift($source_id_value), '=');
+ }
+ $result = $query->execute();
+ return $result->fetchAssoc();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getRowByDestination(array $destination_id_values) {
+ $query = $this->getDatabase()->select($this->mapTable, 'map')
+ ->fields('map');
+ foreach ($this->destinationIdFields as $destination_id) {
+ $query = $query->condition("map.$destination_id", array_shift($destination_id_values), '=');
+ }
+ $result = $query->execute();
+ return $result->fetchAssoc();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getRowsNeedingUpdate($count) {
+ $rows = array();
+ $result = $this->getDatabase()->select($this->mapTable, 'map')
+ ->fields('map')
+ ->condition('needs_update', MigrateIdMapInterface::STATUS_NEEDS_UPDATE)
+ ->range(0, $count)
+ ->execute();
+ foreach ($result as $row) {
+ $rows[] = $row;
+ }
+ return $rows;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function lookupSourceID(array $destination_id) {
+ $query = $this->getDatabase()->select($this->mapTable, 'map')
+ ->fields('map', $this->sourceIdFields);
+ foreach ($this->destinationIdFields as $key_name) {
+ $query = $query->condition("map.$key_name", array_shift($destination_id), '=');
+ }
+ $result = $query->execute();
+ $source_id = $result->fetchAssoc();
+ return $source_id;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function lookupDestinationID(array $source_id) {
+ $query = $this->getDatabase()->select($this->mapTable, 'map')
+ ->fields('map', $this->destinationIdFields);
+ foreach ($this->sourceIdFields as $key_name) {
+ $query = $query->condition("map.$key_name", array_shift($source_id), '=');
+ }
+ $result = $query->execute();
+ $destination_id = $result->fetchAssoc();
+ return $destination_id;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function saveIdMapping(Row $row, array $destination_id_values, $needs_update = MigrateIdMapInterface::STATUS_IMPORTED, $rollback_action = MigrateIdMapInterface::ROLLBACK_DELETE) {
+ // Construct the source key.
+ $source_id_values = $row->getSourceIdValues();
+ // Construct the source key and initialize to empty variable keys.
+ $keys = array();
+ foreach ($this->sourceIdFields as $field_name => $key_name) {
+ // A NULL key value will fail.
+ if (!isset($source_id_values[$field_name])) {
+ $this->message->display(t(
+ 'Could not save to map table due to NULL value for key field !field',
+ array('!field' => $field_name)));
+ return;
+ }
+ $keys[$key_name] = $source_id_values[$field_name];
+ }
+
+ $fields = array(
+ 'needs_update' => (int) $needs_update,
+ 'rollback_action' => (int) $rollback_action,
+ 'hash' => $row->getHash(),
+ );
+ $count = 1;
+ foreach ($destination_id_values as $dest_id) {
+ $fields['destid' . $count++] = $dest_id;
+ }
+ if ($this->migration->get('trackLastImported')) {
+ $fields['last_imported'] = time();
+ }
+ if ($keys) {
+ $this->getDatabase()->merge($this->mapTable)
+ ->key($keys)
+ ->fields($fields)
+ ->execute();
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function saveMessage(array $source_id_values, $message, $level = MigrationInterface::MESSAGE_ERROR) {
+ $count = 1;
+ foreach ($source_id_values as $id_value) {
+ $fields['sourceid' . $count++] = $id_value;
+ // If any key value is empty, we can't save - print out and abort.
+ if (empty($id_value)) {
+ print($message);
+ return;
+ }
+ }
+ $fields['level'] = $level;
+ $fields['message'] = $message;
+ $this->getDatabase()->insert($this->messageTable)
+ ->fields($fields)
+ ->execute();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function prepareUpdate() {
+ $this->getDatabase()->update($this->mapTable)
+ ->fields(array('needs_update' => MigrateIdMapInterface::STATUS_NEEDS_UPDATE))
+ ->execute();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function processedCount() {
+ return $this->getDatabase()->select($this->mapTable)
+ ->countQuery()
+ ->execute()
+ ->fetchField();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function importedCount() {
+ return $this->getDatabase()->select($this->mapTable)
+ ->condition('needs_update', array(MigrateIdMapInterface::STATUS_IMPORTED, MigrateIdMapInterface::STATUS_NEEDS_UPDATE), 'IN')
+ ->countQuery()
+ ->execute()
+ ->fetchField();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function updateCount() {
+ return $this->countHelper(MigrateIdMapInterface::STATUS_NEEDS_UPDATE);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function errorCount() {
+ return $this->countHelper(MigrateIdMapInterface::STATUS_FAILED);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function messageCount() {
+ return $this->countHelper(NULL, $this->messageTable);
+ }
+
+ /**
+ * Counts records in a table.
+ *
+ * @param $status
+ * An integer for the needs_update column.
+ * @param $table
+ * The table to work
+ * @return int
+ * The number of records.
+ */
+ protected function countHelper($status, $table = NULL) {
+ $query = $this->getDatabase()->select($table ?: $this->mapTable);
+ if (isset($status)) {
+ $query->condition('needs_update', $status);
+ }
+ return $query->countQuery()->execute()->fetchField();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function delete(array $source_id_values, $messages_only = FALSE) {
+ if (empty($source_id_values)) {
+ throw new MigrateException('Without source identifier values it is impossible to find the row to delete.');
+ }
+ if (!$messages_only) {
+ $map_query = $this->getDatabase()->delete($this->mapTable);
+ }
+ $message_query = $this->getDatabase()->delete($this->messageTable);
+ $count = 1;
+ foreach ($source_id_values as $id_value) {
+ if (!$messages_only) {
+ $map_query->condition('sourceid' . $count, $id_value);
+ }
+ $message_query->condition('sourceid' . $count, $id_value);
+ $count++;
+ }
+
+ if (!$messages_only) {
+ $map_query->execute();
+ }
+ $message_query->execute();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function deleteDestination(array $destination_id) {
+ $map_query = $this->getDatabase()->delete($this->mapTable);
+ $message_query = $this->getDatabase()->delete($this->messageTable);
+ $source_id = $this->lookupSourceID($destination_id);
+ if (!empty($source_id)) {
+ $count = 1;
+ foreach ($destination_id as $key_value) {
+ $map_query->condition('destid' . $count, $key_value);
+ $count++;
+ }
+ $map_query->execute();
+ $count = 1;
+ foreach ($source_id as $key_value) {
+ $message_query->condition('sourceid' . $count, $key_value);
+ $count++;
+ }
+ $message_query->execute();
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function setUpdate(array $source_id) {
+ if (empty($source_ids)) {
+ throw new MigrateException('No source identifiers provided to update.');
+ }
+ $query = $this->getDatabase()
+ ->update($this->mapTable)
+ ->fields(array('needs_update' => MigrateIdMapInterface::STATUS_NEEDS_UPDATE));
+ $count = 1;
+ foreach ($source_id as $key_value) {
+ $query->condition('sourceid' . $count++, $key_value);
+ }
+ $query->execute();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function deleteBulk(array $source_id_values) {
+ // If we have a single-column key, we can shortcut it.
+ if (count($this->sourceIds) == 1) {
+ $sourceids = array();
+ foreach ($source_id_values as $source_id) {
+ $sourceids[] = $source_id;
+ }
+ $this->getDatabase()->delete($this->mapTable)
+ ->condition('sourceid1', $sourceids, 'IN')
+ ->execute();
+ $this->getDatabase()->delete($this->messageTable)
+ ->condition('sourceid1', $sourceids, 'IN')
+ ->execute();
+ }
+ else {
+ foreach ($source_id_values as $source_id) {
+ $map_query = $this->getDatabase()->delete($this->mapTable);
+ $message_query = $this->getDatabase()->delete($this->messageTable);
+ $count = 1;
+ foreach ($source_id as $key_value) {
+ $map_query->condition('sourceid' . $count, $key_value);
+ $message_query->condition('sourceid' . $count++, $key_value);
+ }
+ $map_query->execute();
+ $message_query->execute();
+ }
+ }
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function clearMessages() {
+ $this->getDatabase()->truncate($this->messageTable)->execute();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function destroy() {
+ $this->getDatabase()->schema()->dropTable($this->mapTable);
+ $this->getDatabase()->schema()->dropTable($this->messageTable);
+ }
+
+ /**
+ * Implementation of Iterator::rewind().
+ *
+ * This is called before beginning a foreach loop.
+ *
+ * @todo Support idlist, itemlimit.
+ */
+ public function rewind() {
+ $this->currentRow = NULL;
+ $fields = array();
+ foreach ($this->sourceIdFields as $field) {
+ $fields[] = $field;
+ }
+ foreach ($this->destinationIdFields as $field) {
+ $fields[] = $field;
+ }
+
+ // @todo Make this work.
+ /*
+ if (isset($this->options['itemlimit'])) {
+ $query = $query->range(0, $this->options['itemlimit']);
+ }
+ */
+ $this->result = $this->getDatabase()->select($this->mapTable, 'map')
+ ->fields('map', $fields)
+ ->execute();
+ $this->next();
+ }
+
+ /**
+ * Implementation of Iterator::current().
+ *
+ * This is called when entering a loop iteration, returning the current row.
+ */
+ public function current() {
+ return $this->currentRow;
+ }
+
+ /**
+ * Implementation of Iterator::key().
+ *
+ * This is called when entering a loop iteration, returning the key of the
+ * current row. It must be a scalar - we will serialize to fulfill the
+ * requirement, but using getCurrentKey() is preferable.
+ */
+ public function key() {
+ return serialize($this->currentKey);
+ }
+
+ /**
+ * Implementation of Iterator::next().
+ *
+ * This is called at the bottom of the loop implicitly, as well as explicitly
+ * from rewind().
+ */
+ public function next() {
+ $this->currentRow = $this->result->fetchObject();
+ $this->currentKey = array();
+ if (!is_object($this->currentRow)) {
+ $this->currentRow = NULL;
+ }
+ else {
+ foreach ($this->sourceIdFields as $map_field) {
+ $this->currentKey[$map_field] = $this->currentRow->$map_field;
+ // Leave only destination fields.
+ unset($this->currentRow->$map_field);
+ }
+ }
+ }
+
+ /**
+ * Implementation of Iterator::valid().
+ *
+ * This is called at the top of the loop, returning TRUE to process the loop
+ * and FALSE to terminate it.
+ */
+ public function valid() {
+ // @todo Check numProcessed against itemlimit.
+ return !is_null($this->currentRow);
+ }
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/process/DefaultValue.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/process/DefaultValue.php
new file mode 100644
index 000000000000..580eed86ea27
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/process/DefaultValue.php
@@ -0,0 +1,29 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\migrate\process\DefaultValue.
+ */
+
+namespace Drupal\migrate\Plugin\migrate\process;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\migrate\MigrateExecutable;
+use Drupal\migrate\Plugin\MigrateProcessInterface;
+use Drupal\migrate\Row;
+
+
+/**
+ * This plugin sets missing values on the destination.
+ *
+ * @PluginId("default_value")
+ */
+class DefaultValue extends PluginBase implements MigrateProcessInterface {
+
+ /**
+ * {@inheritdoc}
+ */
+ public function transform($value, MigrateExecutable $migrate_executable, Row $row, $destination_property) {
+ return isset($value) ? $value : $this->configuration['default_value'];
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/process/Get.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/process/Get.php
new file mode 100644
index 000000000000..6f2f51e7e230
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/process/Get.php
@@ -0,0 +1,55 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\migrate\process\CopyFromSource.
+ */
+
+namespace Drupal\migrate\Plugin\migrate\process;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\migrate\MigrateExecutable;
+use Drupal\migrate\Plugin\MigrateProcessInterface;
+use Drupal\migrate\Row;
+
+/**
+ * This plugin copies from the source to the destination.
+ *
+ * @PluginId("get")
+ */
+class Get extends PluginBase implements MigrateProcessInterface {
+
+ /**
+ * {@inheritdoc}
+ */
+ public function transform($value, MigrateExecutable $migrate_executable, Row $row, $destination_property) {
+ $source = $this->configuration['source'];
+ $properties = is_string($source) ? array($source) : $source;
+ $return = array();
+ foreach ($properties as $property) {
+ if (empty($property)) {
+ $return[] = $value;
+ }
+ else {
+ $is_source = TRUE;
+ if ($property[0] == '@') {
+ $property = preg_replace_callback('/^(@?)((?:@@)*)([^@]|$)/', function ($matches) use (&$is_source) {
+ // If there are an odd number of @ in the beginning, it's a
+ // destination.
+ $is_source = empty($matches[1]);
+ // Remove the possible escaping and do not lose the terminating
+ // non-@ either.
+ return str_replace('@@', '@', $matches[2]) . $matches[3];
+ }, $property);
+ }
+ if ($is_source) {
+ $return[] = $row->getSourceProperty($property);
+ }
+ else {
+ $return[] = $row->getDestinationProperty($property);
+ }
+ }
+ }
+ return is_string($source) ? $return[0] : $return;
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/D6Variable.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/D6Variable.php
new file mode 100644
index 000000000000..3160d53bc21c
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/D6Variable.php
@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\migrate\source\d6\Variable.
+ */
+
+namespace Drupal\migrate\Plugin\migrate\source;
+
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\Plugin\migrate\source\d6\Drupal6SqlBase;
+
+/**
+ * Drupal 6 variable source from database.
+ *
+ * @PluginID("drupal6_variable")
+ */
+class D6Variable extends Drupal6SqlBase {
+
+ /**
+ * The variable names to fetch.
+ *
+ * @var array
+ */
+ protected $variables;
+
+ /**
+ * {@inheritdoc}
+ */
+ function __construct(array $configuration, $plugin_id, array $plugin_definition, MigrationInterface $migration) {
+ parent::__construct($configuration, $plugin_id, $plugin_definition, $migration);
+ $this->variables = $this->configuration['variables'];
+ }
+
+ protected function runQuery() {
+ return new \ArrayIterator(array(array_map('unserialize', $this->query()->execute()->fetchAllKeyed())));
+ }
+
+ public function count() {
+ return intval($this->query()->countQuery()->execute()->fetchField() > 0);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function fields() {
+ return drupal_map_assoc($this->variables);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ function query() {
+ return $this->getDatabase()
+ ->select('variable', 'v')
+ ->fields('v', array('name', 'value'))
+ ->condition('name', $this->variables, 'IN');
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/SourcePluginBase.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/SourcePluginBase.php
new file mode 100644
index 000000000000..78eb2fa38bd8
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/SourcePluginBase.php
@@ -0,0 +1,54 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\migrate\source\SourcePluginBase.
+ */
+
+namespace Drupal\migrate\Plugin\migrate\source;
+
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\Plugin\MigrateSourceInterface;
+use Drupal\migrate\Row;
+
+abstract class SourcePluginBase extends PluginBase implements MigrateSourceInterface {
+
+ /**
+ * @var \Drupal\Core\Extension\ModuleHandlerInterface
+ */
+ protected $moduleHandler;
+
+ /**
+ * @var \Drupal\migrate\Entity\MigrationInterface
+ */
+ protected $migration;
+
+ /**
+ * {@inheritdoc}
+ */
+ function __construct(array $configuration, $plugin_id, array $plugin_definition, MigrationInterface $migration) {
+ parent::__construct($configuration, $plugin_id, $plugin_definition);
+ $this->migration = $migration;
+ }
+
+ /**
+ * @return \Drupal\Core\Extension\ModuleHandlerInterface
+ */
+ protected function getModuleHandler() {
+ if (!isset($this->moduleHandler)) {
+ $this->moduleHandler = \Drupal::moduleHandler();
+ }
+ return $this->moduleHandler;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function prepareRow(Row $row) {
+ $this->getModuleHandler()->invokeAll('migrate_prepare_row', $row, $this, $this->migration);
+ $this->getModuleHandler()->invokeAll('migrate_ '. $this->migration->id() . '_prepare_row', $row, $this, $this->migration);
+ return TRUE;
+ }
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/SqlBase.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/SqlBase.php
new file mode 100644
index 000000000000..9a17436b9b0f
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/SqlBase.php
@@ -0,0 +1,192 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\migrate\source\SqlBase.
+ */
+
+namespace Drupal\migrate\Plugin\migrate\source;
+
+use Drupal\Core\Database\Database;
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+
+/**
+ * Sources whose data may be fetched via DBTNG.
+ */
+abstract class SqlBase extends SourcePluginBase {
+
+ /**
+ * @var \Drupal\Core\Database\Query\SelectInterface
+ */
+ protected $query;
+
+ /**
+ * @var \Drupal\migrate\Entity\MigrationInterface
+ */
+ protected $migration;
+
+ /**
+ * @var \Drupal\Core\Database\Connection
+ */
+ protected $database;
+
+ /**
+ * {@inheritdoc}
+ */
+ function __construct(array $configuration, $plugin_id, array $plugin_definition, MigrationInterface $migration) {
+ parent::__construct($configuration, $plugin_id, $plugin_definition, $migration);
+ $this->mapJoinable = TRUE;
+ }
+
+ /**
+ * @return \Drupal\Core\Database\Connection
+ */
+ function __toString() {
+ return (string) $this->query;
+ }
+
+ /**
+ * @return \Drupal\Core\Database\Connection
+ */
+ public function getDatabase() {
+ if (!isset($this->database)) {
+ $this->database = static::getDatabaseConnection($this->migration->id(), $this->configuration);
+ }
+ return $this->database;
+ }
+
+ public static function getDatabaseConnection($id, array $configuration) {
+ if (isset($configuration['database'])) {
+ $key = 'migrate_' . $id;
+ Database::addConnectionInfo($key, 'default', $configuration['database']);
+ }
+ else {
+ $key = 'default';
+ }
+ return Database::getConnection('default', $key);
+ }
+
+ protected function select($table, $alias = NULL, array $options = array()) {
+ $options['fetch'] = \PDO::FETCH_ASSOC;
+ return $this->getDatabase()->select($table, $alias, $options);
+ }
+
+ /**
+ * Implementation of MigrateSource::performRewind().
+ *
+ * We could simply execute the query and be functionally correct, but
+ * we will take advantage of the PDO-based API to optimize the query up-front.
+ */
+ protected function runQuery() {
+ $this->query = clone $this->query();
+ $this->query->addTag('migrate');
+ $this->query->addTag('migrate_' . $this->migration->id());
+ $this->query->addMetaData('migration', $this->migration);
+ $highwaterProperty = $this->migration->get('highwaterProperty');
+
+ // Get the key values, for potential use in joining to the map table, or
+ // enforcing idlist.
+ $keys = array();
+ foreach ($this->migration->get('sourceIds') as $field_name => $field_schema) {
+ if (isset($field_schema['alias'])) {
+ $field_name = $field_schema['alias'] . '.' . $field_name;
+ }
+ $keys[] = $field_name;
+ }
+
+ // The rules for determining what conditions to add to the query are as
+ // follows (applying first applicable rule)
+ // 1. If idlist is provided, then only process items in that list (AND key
+ // IN (idlist)). Only applicable with single-value keys.
+ if ($id_list = $this->migration->get('idlist')) {
+ $this->query->condition($keys[0], $id_list, 'IN');
+ }
+ else {
+ // 2. If the map is joinable, join it. We will want to accept all rows
+ // which are either not in the map, or marked in the map as NEEDS_UPDATE.
+ // Note that if highwater fields are in play, we want to accept all rows
+ // above the highwater mark in addition to those selected by the map
+ // conditions, so we need to OR them together (but AND with any existing
+ // conditions in the query). So, ultimately the SQL condition will look
+ // like (original conditions) AND (map IS NULL OR map needs update
+ // OR above highwater).
+ $conditions = $this->query->orConditionGroup();
+ $condition_added = FALSE;
+ if ($this->mapJoinable) {
+ // Build the join to the map table. Because the source key could have
+ // multiple fields, we need to build things up.
+ $count = 1;
+ $map_join = '';
+ $delimiter = '';
+ foreach ($this->migration->get('sourceIds') as $field_name => $field_schema) {
+ if (isset($field_schema['alias'])) {
+ $field_name = $field_schema['alias'] . '.' . $field_name;
+ }
+ $map_join .= "$delimiter$field_name = map.sourceid" . $count++;
+ $delimiter = ' AND ';
+ }
+
+ $alias = $this->query->leftJoin($this->migration->getIdMap()->getQualifiedMapTable(), 'map', $map_join);
+ $conditions->isNull($alias . '.sourceid1');
+ $conditions->condition($alias . '.needs_update', MigrateIdMapInterface::STATUS_NEEDS_UPDATE);
+ $condition_added = TRUE;
+
+ // And as long as we have the map table, add its data to the row.
+ $n = count($this->migration->get('sourceIds'));
+ for ($count = 1; $count <= $n; $count++) {
+ $map_key = 'sourceid' . $count;
+ $this->query->addField($alias, $map_key, "migrate_map_$map_key");
+ }
+ $n = count($this->migration->get('destinationIds'));
+ for ($count = 1; $count <= $n; $count++) {
+ $map_key = 'destid' . $count++;
+ $this->query->addField($alias, $map_key, "migrate_map_$map_key");
+ }
+ $this->query->addField($alias, 'needs_update', 'migrate_map_needs_update');
+ }
+ // 3. If we are using highwater marks, also include rows above the mark.
+ // But, include all rows if the highwater mark is not set.
+ if (isset($highwaterProperty['name']) && ($highwater = $this->migration->getHighwater()) !== '') {
+ if (isset($highwaterProperty['alias'])) {
+ $highwater = $highwaterProperty['alias'] . '.' . $highwaterProperty['name'];
+ }
+ else {
+ $highwater = $highwaterProperty['name'];
+ }
+ $conditions->condition($highwater, $highwater, '>');
+ $condition_added = TRUE;
+ }
+ if ($condition_added) {
+ $this->query->condition($conditions);
+ }
+ }
+
+ return new \IteratorIterator($this->query->execute());
+ }
+
+ /**
+ * @return \Drupal\Core\Database\Query\SelectInterface
+ */
+ abstract function query();
+
+ /**
+ * {@inheritdoc}
+ */
+ public function count() {
+ return $this->query()->countQuery()->execute()->fetchField();
+ }
+
+ /**
+ * Returns the iterator that will yield the row arrays to be processed.
+ *
+ * @return \Iterator
+ */
+ public function getIterator() {
+ if (!isset($this->iterator)) {
+ $this->iterator = $this->runQuery();
+ }
+ return $this->iterator;
+ }
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/d6/Drupal6SqlBase.php b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/d6/Drupal6SqlBase.php
new file mode 100644
index 000000000000..579d87a51e1b
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Plugin/migrate/source/d6/Drupal6SqlBase.php
@@ -0,0 +1,82 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\migrate\source\d6\Drupal6SqlBase.
+ */
+
+namespace Drupal\migrate\Plugin\migrate\source\d6;
+
+use Drupal\migrate\Plugin\migrate\source\SqlBase;
+
+/**
+ * A base source class for Drupal 6 migrate sources.
+ *
+ * Mainly to let children retrieve information from the origin system in an
+ * easier way.
+ */
+abstract class Drupal6SqlBase extends SqlBase {
+
+ /**
+ * Retrieves all system data information from origin system.
+ *
+ * @return array
+ * List of system table information keyed by type and name.
+ */
+ public function getSystemData() {
+ static $system_data;
+ if (isset($system_data)) {
+ return $system_data;
+ }
+ $results = $this->database
+ ->select('system', 's')
+ ->fields('s')
+ ->execute();
+ foreach ($results as $result) {
+ $system_data[$result['type']][$result['name']] = $result;
+ }
+ return $system_data;
+ }
+
+ /**
+ * 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) {
+ return isset($system_data['module'][$module]['status']) ? (bool) $system_data['module'][$module]['status'] : FALSE;
+ }
+
+ protected function variableGet($name, $default) {
+ try {
+ $result = $this->database
+ ->query('SELECT value FROM {variable} WHERE name = :name', array(':name' => $name))
+ ->fetchField();
+ }
+ // The table might not exist.
+ catch (\Exception $e) {
+ $result = FALSE;
+ }
+ return $result !== FALSE ? unserialize($result) : $default;
+ }
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Row.php b/core/modules/migrate/lib/Drupal/migrate/Row.php
new file mode 100644
index 000000000000..53ad14dbde4d
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Row.php
@@ -0,0 +1,264 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Row.
+ */
+
+namespace Drupal\migrate;
+
+use Drupal\Component\Utility\NestedArray;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+
+/**
+ * Stores a row.
+ */
+class Row {
+
+ /**
+ * The actual values of the source row.
+ *
+ * @var array
+ */
+ protected $source = array();
+
+ /**
+ * The source identifiers.
+ *
+ * @var array
+ */
+ protected $sourceIds = array();
+
+ /**
+ * The destination values.
+ *
+ * @var array
+ */
+ protected $destination = array();
+
+ /**
+ * The mapping between source and destination identifiers.
+ *
+ * @var array
+ */
+ protected $idMap = array(
+ 'original_hash' => '',
+ 'hash' => '',
+ 'needs_update' => MigrateIdMapInterface::STATUS_NEEDS_UPDATE,
+ );
+
+ /**
+ * Whether the source has been frozen already.
+ *
+ * Once frozen the source can not be changed any more.
+ *
+ * @var bool
+ */
+ protected $frozen = FALSE;
+
+ /**
+ * Constructs a \Drupal\Migrate\Row object.
+ *
+ * @param array $values
+ * An array of values to add as properties on the object.
+ * @param array $source_ids
+ * An array containing the IDs of the source using the keys as the field
+ * names.
+ *
+ * @throws \InvalidArgumentException
+ * Thrown when a source ID property does not exist.
+ */
+ public function __construct(array $values, array $source_ids) {
+ $this->source = $values;
+ $this->sourceIds = $source_ids;
+ foreach (array_keys($source_ids) as $id) {
+ if (!$this->hasSourceProperty($id)) {
+ throw new \InvalidArgumentException("$id has no value");
+ }
+ }
+ }
+
+ /**
+ * Retrieves the values of the source identifiers.
+ *
+ * @return array
+ * An array containing the values of the source identifiers.
+ */
+ public function getSourceIdValues() {
+ return array_intersect_key($this->source, $this->sourceIds);
+ }
+
+ /**
+ * Determines whether a source has a property.
+ *
+ * @param string $property
+ * A property on the source.
+ *
+ * @return bool
+ * TRUE if the source has property; FALSE otherwise.
+ */
+ public function hasSourceProperty($property) {
+ return isset($this->source[$property]) || array_key_exists($property, $this->source);
+ }
+
+ /**
+ * Retrieves a source property.
+ *
+ * @param string $property
+ * A property on the source.
+ *
+ * @return mixed|null
+ * The found returned property or NULL if not found.
+ */
+ public function getSourceProperty($property) {
+ if (isset($this->source[$property])) {
+ return $this->source[$property];
+ }
+ }
+
+ /**
+ * Returns the whole source array.
+ *
+ * @return array
+ * An array of source plugins.
+ */
+ public function getSource() {
+ return $this->source;
+ }
+
+ /**
+ * Sets a source property.
+ *
+ * This can only be called from the source plugin.
+ *
+ * @param string $property
+ * A property on the source.
+ * @param mixed $data
+ * The property value to set on the source.
+ *
+ * @throws \Exception
+ */
+ public function setSourceProperty($property, $data) {
+ if ($this->frozen) {
+ throw new \Exception("The source is frozen and can't be changed any more");
+ }
+ else {
+ $this->source[$property] = $data;
+ }
+ }
+
+ /**
+ * Freezes the source.
+ */
+ public function freezeSource() {
+ $this->frozen = TRUE;
+ }
+
+ /**
+ * Tests if destination property exists.
+ *
+ * @param array|string $property
+ * An array of properties on the destination.
+ *
+ * @return boolean
+ * TRUE if the destination property exists.
+ */
+ public function hasDestinationProperty($property) {
+ return NestedArray::keyExists($this->destination, explode(':', $property));
+ }
+
+ /**
+ * Sets destination properties.
+ *
+ * @param string $property
+ * The name of the destination property.
+ * @param mixed $value
+ * The property value to set on the destination.
+ */
+ public function setDestinationProperty($property, $value) {
+ NestedArray::setValue($this->destination, explode(':', $property), $value, TRUE);
+ }
+
+ /**
+ * Returns the whole destination array.
+ *
+ * @return array
+ * An array of destination values.
+ */
+ public function getDestination() {
+ return $this->destination;
+ }
+
+ /**
+ * Returns the value of a destination property.
+ *
+ * @param array|string $property
+ * An array of properties on the destination.
+ *
+ * @return mixed
+ * The destination value.
+ */
+ public function getDestinationProperty($property) {
+ return NestedArray::getValue($this->destination, explode(':', $property));
+ }
+
+ /**
+ * Sets the Migrate ID mappings.
+ *
+ * @param array $id_map
+ * An array of mappings between source ID and destination ID.
+ */
+ public function setIdMap(array $id_map) {
+ $this->idMap = $id_map;
+ }
+
+ /**
+ * Retrieves the Migrate ID mappings.
+ *
+ * @return array
+ * An array of mapping between source and destination identifiers.
+ */
+ public function getIdMap() {
+ return $this->idMap;
+ }
+
+ /**
+ * Recalculates the hash for the row.
+ */
+ public function rehash() {
+ $this->idMap['original_hash'] = $this->idMap['hash'];
+ $this->idMap['hash'] = hash('sha256', serialize($this->source));
+ }
+
+ /**
+ * Checks whether the row has changed compared to the original ID map.
+ *
+ * @return bool
+ * TRUE if the row has changed, FALSE otherwise. If setIdMap() was not
+ * called, this always returns FALSE.
+ */
+ public function changed() {
+ return $this->idMap['original_hash'] != $this->idMap['hash'];
+ }
+
+ /**
+ * Returns if this row needs an update.
+ *
+ * @return bool
+ * TRUE if the row needs updating, FALSE otherwise.
+ */
+ public function needsUpdate() {
+ return $this->idMap['needs_update'] == MigrateIdMapInterface::STATUS_NEEDS_UPDATE;
+ }
+
+ /**
+ * Returns the hash for the source values..
+ *
+ * @return mixed
+ * The hash of the source values.
+ */
+ public function getHash() {
+ return $this->idMap['hash'];
+ }
+
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Source.php b/core/modules/migrate/lib/Drupal/migrate/Source.php
new file mode 100644
index 000000000000..ebec10479d59
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Source.php
@@ -0,0 +1,413 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Plugin\migrate\source\SourceBase.
+ */
+
+namespace Drupal\migrate;
+
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\Plugin\MigrateIdMapInterface;
+
+/**
+ * Source is a caching / decision making wrapper around the source plugin.
+ *
+ * Derived classes are expected to define __toString(), returning a string
+ * describing the source and significant options, i.e. the query.
+ *
+ * @see \Drupal\migrate\MigrateSourceInterface
+ */
+class Source implements \Iterator, \Countable {
+
+ /**
+ * The current row from the quey
+ *
+ * @var \Drupal\Migrate\Row
+ */
+ protected $currentRow;
+
+ /**
+ * The primary key of the current row
+ *
+ * @var array
+ */
+ protected $currentIds;
+
+ /**
+ * Number of rows intentionally ignored (prepareRow() returned FALSE)
+ *
+ * @var int
+ */
+ protected $numIgnored = 0;
+
+ /**
+ * Number of rows we've at least looked at.
+ *
+ * @var int
+ */
+ protected $numProcessed = 0;
+
+ /**
+ * The highwater mark at the beginning of the import operation.
+ *
+ * @var
+ */
+ protected $originalHighwater = '';
+
+ /**
+ * List of source IDs to process.
+ *
+ * @var array
+ */
+ protected $idList = array();
+
+ /**
+ * Whether this instance should cache the source count.
+ *
+ * @var boolean
+ */
+ protected $cacheCounts = FALSE;
+
+ /**
+ * Key to use for caching counts.
+ *
+ * @var string
+ */
+ protected $cacheKey;
+
+ /**
+ * Whether this instance should not attempt to count the source.
+ *
+ * @var boolean
+ */
+ protected $skipCount = FALSE;
+
+ /**
+ * If TRUE, we will maintain hashed source rows to determine whether incoming
+ * data has changed.
+ *
+ * @var bool
+ */
+ protected $trackChanges = FALSE;
+
+ /**
+ * By default, next() will directly read the map row and add it to the data
+ * row. A source plugin implementation may do this itself (in particular, the
+ * SQL source can incorporate the map table into the query) - if so, it should
+ * set this TRUE so we don't duplicate the effort.
+ *
+ * @var bool
+ */
+ protected $mapRowAdded = FALSE;
+
+ /**
+ * @var array
+ */
+ protected $sourceIds;
+
+ /**
+ * @var \Drupal\Core\Cache\CacheBackendInterface
+ */
+ protected $cache;
+
+ /**
+ * @var \Drupal\migrate\Plugin\MigrateIdMapInterface
+ */
+ protected $idMap;
+
+ /**
+ * @var array
+ */
+ protected $highwaterProperty;
+
+ public function getCurrentIds() {
+ return $this->currentIds;
+ }
+
+ public function getIgnored() {
+ return $this->numIgnored;
+ }
+
+ public function getProcessed() {
+ return $this->numProcessed;
+ }
+
+ /**
+ * Reset numIgnored back to 0.
+ */
+ public function resetStats() {
+ $this->numIgnored = 0;
+ }
+
+ /**
+ * Return a count of available source records, from the cache if appropriate.
+ * Returns -1 if the source is not countable.
+ *
+ * @param boolean $refresh
+ * @return int
+ */
+ public function count($refresh = FALSE) {
+ if ($this->skipCount) {
+ return -1;
+ }
+ $source = $this->migration->getSourcePlugin();
+
+ if (!isset($this->cacheKey)) {
+ $this->cacheKey = hash('sha256', (string) $source);
+ }
+
+ // If a refresh is requested, or we're not caching counts, ask the derived
+ // class to get the count from the source.
+ if ($refresh || !$this->cacheCounts) {
+ $count = $source->count();
+ $this->cache->set($this->cacheKey, $count, 'cache');
+ }
+ else {
+ // Caching is in play, first try to retrieve a cached count.
+ $cache_object = $this->cache->get($this->cacheKey, 'cache');
+ if (is_object($cache_object)) {
+ // Success
+ $count = $cache_object->data;
+ }
+ else {
+ // No cached count, ask the derived class to count 'em up, and cache
+ // the result
+ $count = $source->count();
+ $this->cache->set($this->cacheKey, $count, 'cache');
+ }
+ }
+ return $count;
+ }
+
+ /**
+ * Class constructor.
+ *
+ * @param \Drupal\migrate\Entity\MigrationInterface $migration
+ * @param \Drupal\migrate\MigrateExecutable $migrate_executable
+ */
+ function __construct(MigrationInterface $migration, MigrateExecutable $migrate_executable) {
+ $this->migration = $migration;
+ $this->migrateExecutable = $migrate_executable;
+ $configuration = $migration->get('source');
+ if (!empty($configuration['cache_counts'])) {
+ $this->cacheCounts = TRUE;
+ }
+ if (!empty($configuration['skip_count'])) {
+ $this->skipCount = TRUE;
+ }
+ if (!empty($configuration['cache_key'])) {
+ $this->cacheKey = $configuration['cache_key'];
+ }
+ if (!empty($configuration['track_changes'])) {
+ $this->trackChanges = $configuration['track_changes'];
+ }
+ }
+
+ /**
+ * @return \Drupal\Core\Cache\CacheBackendInterface
+ */
+ protected function getCache() {
+ if (!isset($this->cache)) {
+ $this->cache = \Drupal::cache('migrate');
+ }
+ return $this->cache;
+ }
+
+ /**
+ * @return \Iterator
+ */
+ protected function getIterator() {
+ if (!isset($this->iterator)) {
+ $this->iterator = $this->migration->getSourcePlugin()->getIterator();
+ }
+ return $this->iterator;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function current() {
+ return $this->currentRow;
+ }
+
+ /**
+ * Implementation of Iterator::key - called when entering a loop iteration, returning
+ * the key of the current row. It must be a scalar - we will serialize
+ * to fulfill the requirement, but using getCurrentIds() is preferable.
+ */
+ public function key() {
+ return serialize($this->currentIds);
+ }
+
+ /**
+ * Implementation of Iterator::valid() - called at the top of the loop, returning
+ * TRUE to process the loop and FALSE to terminate it
+ */
+ public function valid() {
+ return isset($this->currentRow);
+ }
+
+ /**
+ * Implementation of Iterator::rewind() - subclasses of MigrateSource should
+ * implement performRewind() to do any class-specific setup for iterating
+ * source records.
+ */
+ public function rewind() {
+ $this->idMap = $this->migration->getIdMap();
+ $this->numProcessed = 0;
+ $this->numIgnored = 0;
+ $this->originalHighwater = $this->migration->getHighwater();
+ $this->highwaterProperty = $this->migration->get('highwaterProperty');
+ if ($id_list = $this->migration->get('idlist')) {
+ $this->idList = $id_list;
+ }
+ $this->getIterator()->rewind();
+ $this->next();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function next() {
+ $this->currentIds = NULL;
+ $this->currentRow = NULL;
+
+ while ($this->getIterator()->valid()) {
+ $row_data = $this->getIterator()->current();
+ $this->getIterator()->next();
+ $row = new Row($row_data, $this->migration->get('sourceIds'), $this->migration->get('destinationIds'));
+
+ // Populate the source key for this row
+ $this->currentIds = $row->getSourceIdValues();
+
+ // Pick up the existing map row, if any, unless getNextRow() did it.
+ if (!$this->mapRowAdded && ($id_map = $this->idMap->getRowBySource($this->currentIds))) {
+ $row->setIdMap($id_map);
+ }
+
+ // First, determine if this row should be passed to prepareRow(), or
+ // skipped entirely. The rules are:
+ // 1. If there's an explicit idlist, that's all we care about (ignore
+ // highwaters and map rows).
+ $prepared = FALSE;
+ if (!empty($this->idList)) {
+ if (in_array(reset($this->currentIds), $this->idList)) {
+ // In the list, fall through.
+ }
+ else {
+ // Not in the list, skip it
+ continue;
+ }
+ }
+ // 2. If the row is not in the map (we have never tried to import it
+ // before), we always want to try it.
+ elseif (!$row->getIdMap()) {
+ // Fall through
+ }
+ // 3. If the row is marked as needing update, pass it.
+ elseif ($row->needsUpdate()) {
+ // Fall through
+ }
+ // 4. At this point, we have a row which has previously been imported and
+ // not marked for update. If we're not using highwater marks, then we
+ // will not take this row. Except, if we're looking for changes in the
+ // data, we need to go through prepareRow() before we can decide to
+ // skip it.
+ elseif (!empty($highwater['field'])) {
+ if ($this->trackChanges) {
+ if ($this->prepareRow($row) !== FALSE) {
+ if ($row->changed()) {
+ // This is a keeper
+ $this->currentRow = $row;
+ break;
+ }
+ else {
+ // No change, skip it.
+ continue;
+ }
+ }
+ else {
+ // prepareRow() told us to skip it.
+ continue;
+ }
+ }
+ else {
+ // No highwater and not tracking changes, skip.
+ continue;
+ }
+ }
+ // 5. The initial highwater mark, before anything is migrated, is ''. We
+ // want to make sure we don't mistakenly skip rows with a highwater
+ // field value of 0, so explicitly handle '' here.
+ elseif ($this->originalHighwater === '') {
+ // Fall through
+ }
+ // 6. So, we are using highwater marks. Take the row if its highwater
+ // field value is greater than the saved mark, otherwise skip it.
+ else {
+ // Call prepareRow() here, in case the highwaterField needs preparation
+ if ($this->prepareRow($row) !== FALSE) {
+ if ($row->getSourceProperty($this->highwaterProperty['name']) > $this->originalHighwater) {
+ $this->currentRow = $row;
+ break;
+ }
+ else {
+ // Skip
+ continue;
+ }
+ }
+ $prepared = TRUE;
+ }
+
+ // Allow the Migration to prepare this row. prepareRow() can return boolean
+ // FALSE to ignore this row.
+ if (!$prepared) {
+ if ($this->prepareRow($row) !== FALSE) {
+ // Finally, we've got a keeper.
+ $this->currentRow = $row;
+ break;
+ }
+ else {
+ $this->currentRow = NULL;
+ }
+ }
+ }
+ if ($this->currentRow) {
+ $this->currentRow->freezeSource();
+ }
+ else {
+ $this->currentIds = NULL;
+ }
+ }
+
+ /**
+ * Source classes should override this as necessary and manipulate $keep.
+ *
+ * @param \Drupal\migrate\Row $row
+ */
+ protected function prepareRow(Row $row) {
+ // We're explicitly skipping this row - keep track in the map table
+ if ($this->migration->getSourcePlugin()->prepareRow($row) === FALSE) {
+ // Make sure we replace any previous messages for this item with any
+ // new ones.
+ $id_map = $this->migration->getIdMap();
+ $id_map->delete($this->currentIds, TRUE);
+ $this->migrateExecutable->saveQueuedMessages();
+ $id_map->saveIdMapping($row, array(), MigrateIdMapInterface::STATUS_IGNORED, $this->migrateExecutable->rollbackAction);
+ $this->numIgnored++;
+ $this->currentRow = NULL;
+ $this->currentIds = NULL;
+ }
+ else {
+ // When tracking changed data, We want to quietly skip (rather than
+ // "ignore") rows with changes. The caller needs to make that decision,
+ // so we need to provide them with the necessary information (before and
+ // after hashes).
+ if ($this->trackChanges) {
+ $row->rehash();
+ }
+ }
+ $this->numProcessed++;
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemCron.php b/core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemCron.php
new file mode 100644
index 000000000000..9171fff7bd65
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemCron.php
@@ -0,0 +1,59 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\Drupal6SystemCron.
+ */
+
+namespace Drupal\migrate\Tests\Dump;
+
+use Drupal\Core\Database\Connection;
+
+/**
+ * Database dump for testing system.cron.yml migration.
+ */
+class Drupal6SystemCron {
+
+ /**
+ * Sample database schema and values.
+ *
+ * @param \Drupal\Core\Database\Connection $database
+ * The database connection.
+ */
+ public static function load(Connection $database) {
+ $database->schema()->createTable('variable', array(
+ 'fields' => array(
+ 'name' => array(
+ 'type' => 'varchar',
+ 'length' => 128,
+ 'not null' => TRUE,
+ 'default' => '',
+ ),
+ 'value' => array(
+ 'type' => 'blob',
+ 'not null' => TRUE,
+ 'size' => 'big',
+ 'translatable' => TRUE,
+ ),
+ ),
+ 'primary key' => array(
+ 'name',
+ ),
+ 'module' => 'system',
+ 'name' => 'variable',
+ ));
+ $database->insert('variable')->fields(array(
+ 'name',
+ 'value',
+ ))
+ ->values(array(
+ 'name' => 'cron_threshold_warning',
+ 'value' => 'i:172800;',
+ ))
+ ->values(array(
+ 'name' => 'cron_threshold_error',
+ 'value' => 'i:1209600;',
+ ))
+ ->execute();
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemRss.php b/core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemRss.php
new file mode 100644
index 000000000000..da4468f9a589
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemRss.php
@@ -0,0 +1,55 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\Drupal6SystemRss.
+ */
+
+namespace Drupal\migrate\Tests\Dump;
+
+use Drupal\Core\Database\Connection;
+
+/**
+ * Database dump for testing system.settings.yml migration.
+ */
+class Drupal6SystemRss {
+
+ /**
+ * Sample database schema and values.
+ *
+ * @param \Drupal\Core\Database\Connection $database
+ * The database connection.
+ */
+ public static function load(Connection $database) {
+ $database->schema()->createTable('variable', array(
+ 'fields' => array(
+ 'name' => array(
+ 'type' => 'varchar',
+ 'length' => 128,
+ 'not null' => TRUE,
+ 'default' => '',
+ ),
+ 'value' => array(
+ 'type' => 'blob',
+ 'not null' => TRUE,
+ 'size' => 'big',
+ 'translatable' => TRUE,
+ ),
+ ),
+ 'primary key' => array(
+ 'name',
+ ),
+ 'module' => 'system',
+ 'name' => 'variable',
+ ));
+ $database->insert('variable')->fields(array(
+ 'name',
+ 'value',
+ ))
+ ->values(array(
+ 'name' => 'feed_default_items',
+ 'value' => 'i:10;',
+ ))
+ ->execute();
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemSite.php b/core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemSite.php
new file mode 100644
index 000000000000..69ef685f1db2
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Tests/Dump/Drupal6SystemSite.php
@@ -0,0 +1,75 @@
+<?php
+
+namespace Drupal\migrate\Tests\Dump;
+
+use Drupal\Core\Database\Connection;
+
+/**
+ * Database dump for testing system.site.yml migration.
+ */
+class Drupal6SystemSite {
+
+ /**
+ * @param \Drupal\Core\Database\Connection $database
+ */
+ public static function load(Connection $database) {
+ $database->schema()->createTable('variable', array(
+ 'fields' => array(
+ 'name' => array(
+ 'type' => 'varchar',
+ 'length' => 128,
+ 'not null' => TRUE,
+ 'default' => '',
+ ),
+ 'value' => array(
+ 'type' => 'blob',
+ 'not null' => TRUE,
+ 'size' => 'big',
+ 'translatable' => TRUE,
+ ),
+ ),
+ 'primary key' => array(
+ 'name',
+ ),
+ 'module' => 'system',
+ 'name' => 'variable',
+ ));
+ $database->insert('variable')->fields(array(
+ 'name',
+ 'value',
+ ))
+ ->values(array(
+ 'name' => 'site_name',
+ 'value' => 's:6:"drupal";',
+ ))
+ ->values(array(
+ 'name' => 'site_mail',
+ 'value' => 's:17:"admin@example.com";',
+ ))
+ ->values(array(
+ 'name' => 'site_slogan',
+ 'value' => 's:13:"Migrate rocks";',
+ ))
+ ->values(array(
+ 'name' => 'site_frontpage',
+ 'value' => 's:12:"anonymous-hp";',
+ ))
+ ->values(array(
+ 'name' => 'site_403',
+ 'value' => 's:4:"user";',
+ ))
+ ->values(array(
+ 'name' => 'site_404',
+ 'value' => 's:14:"page-not-found";',
+ ))
+ ->values(array(
+ 'name' => 'drupal_weight_select_max',
+ 'value' => 'i:99;',
+ ))
+ ->values(array(
+ 'name' => 'admin_compact_mode',
+ 'value' => 'b:0;',
+ ))
+ ->execute();
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Tests/MigrateSystemConfigsTest.php b/core/modules/migrate/lib/Drupal/migrate/Tests/MigrateSystemConfigsTest.php
new file mode 100644
index 000000000000..09529c15a15d
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Tests/MigrateSystemConfigsTest.php
@@ -0,0 +1,75 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\system\Tests\Upgrade\MigrateSystemSiteTest.
+ */
+
+namespace Drupal\migrate\Tests;
+
+use Drupal\migrate\MigrateMessage;
+use Drupal\migrate\MigrateExecutable;
+
+class MigrateSystemConfigsTest extends MigrateTestBase {
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function getInfo() {
+ return array(
+ 'name' => 'Migrate variables to system.*.yml',
+ 'description' => 'Upgrade variables to system.*.yml',
+ 'group' => 'Migrate',
+ );
+ }
+
+ function testSystemSite() {
+ $migration = entity_load('migration', 'd6_system_site');
+ $dumps = array(
+ drupal_get_path('module', 'migrate') . '/lib/Drupal/migrate/Tests/Dump/Drupal6SystemSite.php',
+ );
+ $this->prepare($migration, $dumps);
+ $executable = new MigrateExecutable($migration, new MigrateMessage);
+ $executable->import();
+ $config = \Drupal::config('system.site');
+ $this->assertIdentical($config->get('name'), 'drupal');
+ $this->assertIdentical($config->get('mail'), 'admin@example.com');
+ $this->assertIdentical($config->get('slogan'), 'Migrate rocks');
+ $this->assertIdentical($config->get('page.front'), 'anonymous-hp');
+ $this->assertIdentical($config->get('page.403'), 'user');
+ $this->assertIdentical($config->get('page.404'), 'page-not-found');
+ $this->assertIdentical($config->get('weight_select_max'), 99);
+ $this->assertIdentical($config->get('admin_compact_mode'), FALSE);
+ }
+
+ /**
+ * Tests migration of system (cron) variables to system.cron.yml.
+ */
+ public function testSystemCron() {
+ $migration = entity_load('migration', 'd6_system_cron');
+ $dumps = array(
+ drupal_get_path('module', 'migrate') . '/lib/Drupal/migrate/Tests/Dump/Drupal6SystemCron.php',
+ );
+ $this->prepare($migration, $dumps);
+ $executable = new MigrateExecutable($migration, new MigrateMessage());
+ $executable->import();
+ $config = \Drupal::config('system.cron');
+ $this->assertIdentical($config->get('threshold.warning'), 172800);
+ $this->assertIdentical($config->get('threshold.error'), 1209600);
+ }
+
+ /**
+ * Tests migration of system (rss) variables to system.rss.yml.
+ */
+ public function testSystemRss() {
+ $migration = entity_load('migration', 'd6_system_rss');
+ $dumps = array(
+ drupal_get_path('module', 'migrate') . '/lib/Drupal/migrate/Tests/Dump/Drupal6SystemRss.php',
+ );
+ $this->prepare($migration, $dumps);
+ $executable = new MigrateExecutable($migration, new MigrateMessage());
+ $executable->import();
+ $config = \Drupal::config('system.rss');
+ $this->assertIdentical($config->get('items.limit'), 10);
+ }
+}
diff --git a/core/modules/migrate/lib/Drupal/migrate/Tests/MigrateTestBase.php b/core/modules/migrate/lib/Drupal/migrate/Tests/MigrateTestBase.php
new file mode 100644
index 000000000000..5b67e5a40663
--- /dev/null
+++ b/core/modules/migrate/lib/Drupal/migrate/Tests/MigrateTestBase.php
@@ -0,0 +1,60 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\system\Tests\Upgrade\MigrateTestBase.
+ */
+
+namespace Drupal\migrate\Tests;
+
+use Drupal\Core\Database\Database;
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\Plugin\migrate\source\SqlBase;
+use Drupal\simpletest\WebTestBase;
+
+class MigrateTestBase extends WebTestBase {
+
+ /**
+ * The file path(s) to the dumped database(s) to load into the child site.
+ *
+ * @var array
+ */
+ var $databaseDumpFiles = array();
+
+ public static $modules = array('migrate');
+
+ /**
+ * @param MigrationInterface $migration
+ * @param array $files
+ *
+ * @return \Drupal\Core\Database\Connection
+ */
+ protected function prepare(MigrationInterface $migration, array $files = array()) {
+ $databasePrefix = 'm_';
+ $connection_info = Database::getConnectionInfo('default');
+ foreach ($connection_info as $target => $value) {
+ $connection_info[$target]['prefix'] = array(
+ 'default' => $value['prefix']['default'] . $databasePrefix,
+ );
+ }
+ $database = SqlBase::getDatabaseConnection($migration->id(), array('database' => $connection_info['default']));
+ foreach (array('source', 'destination', 'idMap') as $key) {
+ $configuration = $migration->get($key);
+ $configuration['database'] = $database;
+ $migration->set($key, $configuration);
+ }
+
+ // Load the database from the portable PHP dump.
+ // The files may be gzipped.
+ foreach ($files as $file) {
+ if (substr($file, -3) == '.gz') {
+ $file = "compress.zlib://$file";
+ require $file;
+ }
+ preg_match('/^namespace (.*);$/m', file_get_contents($file), $matches);
+ $class = $matches[1] . '\\' . basename($file, '.php');
+ $class::load($database);
+ }
+ return $database;
+ }
+}
diff --git a/core/modules/migrate/migrate.api.php b/core/modules/migrate/migrate.api.php
new file mode 100644
index 000000000000..a2d2cb5d0896
--- /dev/null
+++ b/core/modules/migrate/migrate.api.php
@@ -0,0 +1,37 @@
+<?php
+
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\Plugin\MigrateSourceInterface;
+use Drupal\migrate\Row;
+
+/**
+ * @file
+ * Hooks provided by the Migrate module.
+ */
+
+/**
+ * @addtogroup hooks
+ * @{
+ */
+
+/**
+ * Allows adding data to a row before processing it.
+ *
+ * For example, filter module used to store filter format settings in the
+ * variables table which now needs to be inside the filter format config
+ * file. So, it needs to be added here.
+ *
+ * hook_migrate_MIGRATION_ID_prepare_row is also available.
+ */
+function hook_migrate_prepare_row(Row $row, MigrateSourceInterface $source, MigrationInterface $migration) {
+ if ($migration->id() == 'drupal6_filter_formats') {
+ $value = $source->getDatabase()->query('SELECT value FROM {variable} WHERE name = :name', array(':name' => 'mymodule_filter_foo_' . $row->getSourceProperty('format')))->fetchField();
+ if ($value) {
+ $row->setSourceProperty('settings:mymodule:foo', unserialize($value));
+ }
+ }
+}
+
+/**
+ * @} End of "addtogroup hooks".
+ */
diff --git a/core/modules/migrate/migrate.info.yml b/core/modules/migrate/migrate.info.yml
new file mode 100644
index 000000000000..460f66b7edda
--- /dev/null
+++ b/core/modules/migrate/migrate.info.yml
@@ -0,0 +1,7 @@
+name: Migrate
+type: module
+description: 'Handles migrations'
+package: Core
+version: VERSION
+core: 8.x
+;configure: admin/structure/migrate
diff --git a/core/modules/migrate/migrate.module b/core/modules/migrate/migrate.module
new file mode 100644
index 000000000000..e69de29bb2d1
diff --git a/core/modules/migrate/migrate.services.yml b/core/modules/migrate/migrate.services.yml
new file mode 100644
index 000000000000..28848dff5169
--- /dev/null
+++ b/core/modules/migrate/migrate.services.yml
@@ -0,0 +1,23 @@
+services:
+ cache.migrate:
+ class: Drupal\Core\Cache\CacheBackendInterface
+ tags:
+ - { name: cache.bin }
+ factory_method: get
+ factory_service: cache_factory
+ arguments: [migrate]
+ plugin.manager.migrate.source:
+ class: Drupal\migrate\Plugin\MigratePluginManager
+ arguments: [source, '@container.namespaces', '@cache.cache', '@language_manager', '@module_handler']
+ plugin.manager.migrate.process:
+ class: Drupal\migrate\Plugin\MigratePluginManager
+ arguments: [process, '@container.namespaces', '@cache.cache', '@language_manager', '@module_handler']
+ plugin.manager.migrate.destination:
+ class: Drupal\migrate\Plugin\MigratePluginManager
+ arguments: [destination, '@container.namespaces', '@cache.cache', '@language_manager', '@module_handler']
+ plugin.manager.migrate.id_map:
+ class: Drupal\migrate\Plugin\MigratePluginManager
+ arguments: [id_map, '@container.namespaces', '@cache.cache', '@language_manager', '@module_handler']
+ plugin.manager.migrate.entity_field:
+ class: Drupal\migrate\Plugin\MigratePluginManager
+ arguments: [entity_field, '@container.namespaces', '@cache.cache', '@language_manager', '@module_handler']
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/ConditionResolver.php b/core/modules/migrate/tests/Drupal/migrate/Tests/ConditionResolver.php
new file mode 100644
index 000000000000..875f13e920e6
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/ConditionResolver.php
@@ -0,0 +1,93 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\ConditionResolver.
+ */
+
+
+namespace Drupal\migrate\Tests;
+
+use Drupal\Core\Database\Query\Condition;
+
+class ConditionResolver {
+
+ /**
+ * Match a row against a group of conditions.
+ *
+ * @param \Drupal\migrate\tests\DatabaseRowInterface $row
+ *
+ * @param \Drupal\Core\Database\Query\Condition $condition_group
+ *
+ * @return bool
+ */
+ public static function matchGroup(DatabaseRowInterface $row, Condition $condition_group) {
+ $conditions = $condition_group->conditions();
+ $and = $conditions['#conjunction'] == 'AND';
+ unset($conditions['#conjunction']);
+ $match = TRUE;
+ foreach ($conditions as $condition) {
+ $match = $condition['field'] instanceof Condition ? static::matchGroup($row, $condition['field']) : static::matchSingle($row, $condition);
+ // For AND, finish matching on the first fail. For OR, finish on first
+ // success.
+ if ($and != $match) {
+ break;
+ }
+ }
+ return $match;
+ }
+
+ /**
+ * Match a single row and its condition.
+ *
+ * @param \Drupal\migrate\tests\DatabaseRowInterface $row
+ * The row to match.
+ *
+ * @param array $condition
+ * An array representing a single condition.
+ *
+ * @return bool
+ * TRUE if the condition matches.
+ *
+ * @throws \Exception
+ *
+ */
+ protected static function matchSingle(DatabaseRowInterface $row, array $condition) {
+ $row_value = $row->getValue($condition['field']);
+ switch ($condition['operator']) {
+ case '=':
+ return $row_value == $condition['value'];
+
+ case '<=':
+ return $row_value <= $condition['value'];
+
+ case '>=':
+ return $row_value >= $condition['value'];
+
+ case '!=':
+ return $row_value != $condition['value'];
+
+ case '<>':
+ return $row_value != $condition['value'];
+
+ case '<':
+ return $row_value < $condition['value'];
+
+ case '>':
+ return $row_value > $condition['value'];
+
+ case 'IN':
+ return in_array($row_value, $condition['value']);
+
+ case 'IS NULL':
+ return !isset($row_value);
+
+ case 'IS NOT NULL':
+ return isset($row_value);
+
+ default:
+ throw new \Exception(sprintf('operator %s is not supported', $condition['operator']));
+ }
+ }
+
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/D6VariableTest.php b/core/modules/migrate/tests/Drupal/migrate/Tests/D6VariableTest.php
new file mode 100644
index 000000000000..cc903bfd4b91
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/D6VariableTest.php
@@ -0,0 +1,75 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\D6VariableSourceTest.
+ */
+
+namespace Drupal\migrate\Tests;
+
+/**
+ * @group migrate
+ * @group Drupal
+ */
+class D6VariableTest extends MigrateSqlSourceTestCase {
+
+ const PLUGIN_CLASS = 'Drupal\migrate\Plugin\migrate\source\D6Variable';
+
+ protected $migrationConfiguration = array(
+ 'id' => 'test',
+ 'highwaterProperty' => array('field' => 'test'),
+ 'idlist' => array(),
+ 'source' => array(
+ 'plugin' => 'drupal6_variable',
+ 'variables' => array(
+ 'foo',
+ 'bar',
+ ),
+ ),
+ 'sourceIds' => array(),
+ 'destinationIds' => array(),
+ );
+
+ protected $mapJoinable = FALSE;
+
+ protected $expectedResults = array(
+ array(
+ 'foo' => 1,
+ 'bar' => FALSE,
+ ),
+ );
+
+ protected $databaseContents = array(
+ 'variable' => array(
+ array('name' => 'foo', 'value' => 'i:1;'),
+ array('name' => 'bar', 'value' => 'b:0;'),
+ ),
+ );
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function getInfo() {
+ return array(
+ 'name' => 'D6 variable source functionality',
+ 'description' => 'Tests D6 variable source plugin.',
+ 'group' => 'Migrate',
+ );
+ }
+
+}
+
+namespace Drupal\migrate\Tests\source;
+
+use Drupal\Core\Database\Connection;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\migrate\Plugin\migrate\source\D6Variable;
+
+class TestD6Variable extends D6Variable {
+ function setDatabase(Connection $database) {
+ $this->database = $database;
+ }
+ function setModuleHandler(ModuleHandlerInterface $module_handler) {
+ $this->moduleHandler = $module_handler;
+ }
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRow.php b/core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRow.php
new file mode 100644
index 000000000000..1c8cf7663bfd
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRow.php
@@ -0,0 +1,19 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\DatabaseRow.
+ */
+
+namespace Drupal\migrate\Tests;
+
+class DatabaseRow implements DatabaseRowInterface {
+
+ public function __construct(array $row) {
+ $this->row = $row;
+ }
+
+ public function getValue($field) {
+ return $this->row[$field];
+ }
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRowInterface.php b/core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRowInterface.php
new file mode 100644
index 000000000000..cddfa8ba7359
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRowInterface.php
@@ -0,0 +1,13 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\DatabaseRowInterface.
+ */
+
+namespace Drupal\migrate\Tests;
+
+interface DatabaseRowInterface {
+
+ function getValue($field);
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRowSelect.php b/core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRowSelect.php
new file mode 100644
index 000000000000..d4772ab8173f
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/DatabaseRowSelect.php
@@ -0,0 +1,28 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\DatabaseRowSelect.
+ */
+
+namespace Drupal\migrate\Tests;
+
+class DatabaseRowSelect extends DatabaseRow {
+
+ public function __construct(array $row, array $fieldsWithTable, array $fields) {
+ $this->fieldsWithTable = $fieldsWithTable;
+ $this->fields = $fields;
+ parent::__construct($row);
+ }
+
+ public function getValue($field) {
+ $field_info = isset($this->fieldsWithTable[$field]) ? $this->fieldsWithTable[$field] : $this->fields[$field];
+ if (array_key_exists($field_info['field'], $this->row[$field_info['table']]['result'])) {
+ $index = 'result';
+ }
+ else {
+ $index = 'all';
+ }
+ return $this->row[$field_info['table']][$index][$field_info['field']];
+ }
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/FakeDatabaseSchema.php b/core/modules/migrate/tests/Drupal/migrate/Tests/FakeDatabaseSchema.php
new file mode 100644
index 000000000000..1433f180d4e5
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/FakeDatabaseSchema.php
@@ -0,0 +1,149 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\FakeSelect.
+ */
+
+
+namespace Drupal\migrate\Tests;
+
+use Drupal\Core\Database\Schema;
+
+class FakeDatabaseSchema extends Schema {
+
+ /**
+ * As set on MigrateSqlSourceTestCase::databaseContents.
+ */
+ protected $databaseContents;
+
+ public function __construct($database_contents) {
+ $this->uniqueIdentifier = uniqid('', TRUE);
+ // @todo Maybe we can generate an internal representation.
+ $this->databaseContents = $database_contents;
+ }
+
+ public function tableExists($table) {
+ return in_array($table, array_keys($this->databaseContents));
+ }
+
+ public function prefixNonTable($table) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ protected function buildTableNameCondition($table_name, $operator = '=', $add_prefix = TRUE) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ protected function getPrefixInfo($table = 'default', $add_prefix = TRUE) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function addField($table, $field, $spec, $keys_new = array()) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function addIndex($table, $name, $fields) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function addPrimaryKey($table, $fields) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function addUniqueKey($table, $name, $fields) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function changeField($table, $field, $field_new, $spec, $keys_new = array()) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function __clone() {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function copyTable($source, $destination) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function createTable($name, $table) {
+ #throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function dropField($table, $field) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function dropIndex($table, $name) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function dropPrimaryKey($table) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function dropTable($table) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function dropUniqueKey($table, $name) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function fieldExists($table, $column) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function fieldNames($fields) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function fieldSetDefault($table, $field, $default) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function fieldSetNoDefault($table, $field) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function findTables($table_expression) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function getFieldTypeMap() {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function indexExists($table, $name) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function nextPlaceholder() {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function prepareComment($comment, $length = NULL) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function renameTable($table, $new_name) {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ public function uniqueIdentifier() {
+ throw new \Exception(sprintf('Unsupported method "%s"', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function getInfo() {
+ return array(
+ 'name' => 'Fake database schema',
+ 'description' => 'Tests for fake database schema plugin.',
+ 'group' => 'Migrate',
+ );
+ }
+
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/FakeSelect.php b/core/modules/migrate/tests/Drupal/migrate/Tests/FakeSelect.php
new file mode 100644
index 000000000000..9b79234b0df1
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/FakeSelect.php
@@ -0,0 +1,511 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\FakeSelect.
+ */
+
+namespace Drupal\migrate\Tests;
+
+use Drupal\Core\Database\Connection;
+use Drupal\Core\Database\Query\Condition;
+use Drupal\Core\Database\Query\PlaceholderInterface;
+use Drupal\Core\Database\Query\Select;
+use Drupal\Core\Database\Query\SelectInterface;
+
+class FakeSelect extends Select {
+
+ /**
+ * Contents of the pseudo-database.
+ *
+ * Keys are table names and values are arrays of rows in the table.
+ * Every row there contains all table fields keyed by field name.
+ *
+ * @code
+ * array(
+ * 'user' => array(
+ * array(
+ * 'uid' => 1,
+ * 'name' => 'admin',
+ * ),
+ * array(
+ * 'uid' => 2,
+ * 'name' => 'alice',
+ * ),
+ * ),
+ * 'node' => array(
+ * array(
+ * 'nid' => 1,
+ * )
+ * )
+ * )
+ * @endcode
+ *
+ * @var array
+ */
+ protected $databaseContents;
+
+ protected $countQuery = FALSE;
+ protected $fieldsWithTable = array();
+
+ /**
+ * Constructs a new FakeSelect.
+ *
+ * @param string $table
+ * The base table name used within fake select.
+ *
+ * @param string $alias
+ * The base table alias used within fake select.
+ *
+ * @param array $database_contents
+ * An array of mocked database content.
+ *
+ * @param string $conjunction
+ * The operator to use to combine conditions: 'AND' or 'OR'.
+ */
+ public function __construct($table, $alias, array $database_contents, $conjunction = 'AND') {
+ $this->addJoin(NULL, $table, $alias);
+ $this->where = new Condition($conjunction);
+ $this->having = new Condition($conjunction);
+ $this->databaseContents = $database_contents;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function leftJoin($table, $alias = NULL, $condition = NULL, $arguments = array()) {
+ return $this->addJoin('LEFT', $table, $alias, $condition, $arguments);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function addJoin($type, $table, $alias = NULL, $condition = NULL, $arguments = array()) {
+ if ($table instanceof SelectInterface) {
+ // @todo implement this.
+ throw new \Exception('Subqueries are not supported at this moment.');
+ }
+ $alias = parent::addJoin($type, $table, $alias, $condition, $arguments);
+ if (isset($type)) {
+ if ($type != 'INNER' && $type != 'LEFT') {
+ throw new \Exception(sprintf('%s type not supported, only INNER and LEFT.', $type));
+ }
+ if (!preg_match('/(\w+)\.(\w+)\s*=\s*(\w+)\.(\w+)/', $condition, $matches)) {
+ throw new \Exception('Only x.field1 = y.field2 conditions are supported.' . $condition);
+ }
+ if ($matches[1] == $alias) {
+ $this->tables[$alias] += array(
+ 'added_field' => $matches[2],
+ 'original_table_alias' => $matches[3],
+ 'original_field' => $matches[4],
+ );
+ }
+ elseif ($matches[3] == $alias) {
+ $this->tables[$alias] += array(
+ 'added_field' => $matches[4],
+ 'original_table_alias' => $matches[1],
+ 'original_field' => $matches[2],
+ );
+ }
+ else {
+ throw new \Exception('The JOIN condition does not contain the alias of the joined table.');
+ }
+ }
+ return $alias;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function execute() {
+ // @todo: Implement distinct() handling.
+
+ // Single table count queries often do not contain fields which this class
+ // does not support otherwise, so add a shortcut.
+ if (count($this->tables) == 1 && $this->countQuery) {
+ $table_info = reset($this->tables);
+ $where = $this->where;
+ if (!empty($this->databaseContents[$table_info['table']])) {
+ $results = array_filter($this->databaseContents[$table_info['table']], function ($row_array) use ($where) {
+ return ConditionResolver::matchGroup(new DatabaseRow($row_array), $where);
+ });
+ }
+ else {
+ $results = array();
+ }
+ }
+ else {
+ $all_rows = $this->executeJoins();
+ $all_rows = $this->resolveConditions($this->where, $all_rows);
+ if (!empty($this->order)) {
+ usort($all_rows, array($this, 'sortCallback'));
+ }
+ // Now flatten the rows so that each row becomes a field alias => value
+ // array.
+ $results = array();
+ foreach ($all_rows as $table_rows) {
+ $result_row = array();
+ foreach ($table_rows as $row) {
+ $result_row += $row['result'];
+ }
+ $results[] = $result_row;
+ }
+ }
+ if (!empty($this->range)) {
+ $results = array_slice($results, $this->range['start'], $this->range['length']);
+ }
+ if ($this->countQuery) {
+ $results = array(array(count($results)));
+ }
+ return new FakeStatement($results);
+ }
+
+ /**
+ * Create an initial result set by executing the joins and picking fields.
+ *
+ * @return array
+ * A multidimensional array, the first key are table aliases, the second
+ * are field aliases, the values are the database contents or NULL in case
+ * of JOINs.
+ */
+ protected function executeJoins() {
+ // @TODO add support for all_fields.
+ $fields = array();
+ foreach ($this->fields as $field_info) {
+ $this->fieldsWithTable[$field_info['table'] . '.' . $field_info['field']] = $field_info;
+ $fields[$field_info['table']][$field_info['field']] = NULL;
+ }
+ foreach ($this->tables as $alias => $table_info) {
+ if ($table = reset($this->databaseContents[$table_info['table']])) {
+ foreach (array_keys($table) as $field) {
+ if (!isset($this->fields[$field])) {
+ $this->fieldsWithTable[$field] = array(
+ 'table' => $alias,
+ 'field' => $field,
+ );
+ }
+ }
+ }
+ }
+ // This will contain a multiple dimensional array. The first key will be a
+ // table alias, the second either result or all, the third will be a field
+ // alias. all contains every field in the table with the original field
+ // names while result contains only the fields requested. This allows for
+ // filtering on fields that were not added via addField().
+ $results = array();
+ foreach ($this->tables as $table_alias => $table_info) {
+ // The base table for this query.
+ if (empty($table_info['join type'])) {
+ foreach ($this->databaseContents[$table_info['table']] as $candidate_row) {
+ $results[] = $this->getNewRow($table_alias, $fields, $candidate_row);
+ }
+ }
+ else {
+ $new_rows = array();
+
+ // Dynamically build a set of joined rows. Check existing rows and see
+ // if they can be joined with incoming rows.
+ foreach ($results as $row) {
+ $joined = FALSE;
+ foreach ($this->databaseContents[$table_info['table']] as $candidate_row) {
+ if ($row[$table_info['original_table_alias']]['result'][$table_info['original_field']] == $candidate_row[$table_info['added_field']]) {
+ $joined = TRUE;
+ $new_rows[] = $this->getNewRow($table_alias, $fields, $candidate_row, $row);
+ }
+ }
+ if (!$joined && $table_info['join type'] == 'LEFT') {
+ // Because PHP doesn't scope their foreach statements,
+ // $candidate_row may contain the last value assigned to it from the
+ // previous statement.
+ // @TODO: empty tables? Those are a problem.
+ $keys = array_keys($candidate_row);
+ $values = array_fill(0, count($keys), NULL);
+ $new_row = array(
+ 'result' => $fields[$table_alias],
+ 'all' => array_combine($keys, $values),
+ );
+ $new_rows[] = array($table_alias => $new_row) + $row;
+ }
+ }
+ $results = $new_rows;
+ }
+ }
+ return $results;
+ }
+
+ /**
+ * Retrieves a new row.
+ *
+ * @param string $table_alias
+ * @param array $fields
+ * @param array $candidate_row
+ * @param array $row
+ *
+ * @return array
+ */
+ protected function getNewRow($table_alias, $fields, $candidate_row, $row = array()) {
+ $new_row[$table_alias]['all'] = $candidate_row;
+ foreach ($fields[$table_alias] as $field => $v) {
+ $new_row[$table_alias]['result'][$field] = $candidate_row[$field];
+ }
+ return $new_row + $row;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function countQuery() {
+ $query = clone $this;
+ return $query->setCountQuery();
+ }
+
+ /**
+ * Set this query to be a count query.
+ */
+ protected function setCountQuery() {
+ $this->countQuery = TRUE;
+ return $this;
+ }
+
+ /**
+ * usort callback to order the results.
+ */
+ protected function sortCallback($a, $b) {
+ $a_row = new DatabaseRowSelect($a, $this->fieldsWithTable, $this->fields);
+ $b_row = new DatabaseRowSelect($b, $this->fieldsWithTable, $this->fields);
+ foreach ($this->order as $field => $direction) {
+ $a_value = $a_row->getValue($field);
+ $b_value = $b_row->getValue($field);
+ if ($a_value != $b_value) {
+ return (($a_value < $b_value) == ($direction == 'ASC')) ? -1 : 1;
+ }
+ }
+ return 0;
+ }
+
+ /**
+ * Resolves conditions by removing non-matching rows.
+ *
+ * @param \Drupal\Core\Database\Query\Condition $condition_group
+ * The condition group to check.
+ * @param array $rows
+ * An array of rows excluding non-matching rows.
+ */
+ protected function resolveConditions(Condition $condition_group, array &$rows) {
+ $fields_with_table = $this->fieldsWithTable;
+ $fields = $this->fields;
+ return array_filter($rows, function ($row_array) use ($condition_group, $fields_with_table, $fields) {
+ $row = new DatabaseRowSelect($row_array, $fields_with_table, $fields);
+ return ConditionResolver::matchGroup($row, $condition_group);
+ });
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function orderBy($field, $direction = 'ASC') {
+ $this->order[$field] = strtoupper($direction);
+ return $this;
+ }
+
+ // ================== we could support these.
+ /**
+ * {@inheritdoc}
+ */
+ public function groupBy($field) {
+ // @todo: Implement groupBy() method.
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function havingCondition($field, $value = NULL, $operator = NULL) {
+ // @todo: Implement havingCondition() method.
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function uniqueIdentifier() {
+ // TODO: Implement uniqueIdentifier() method.
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ // ================== the rest won't be supported, ever.
+ /**
+ * {@inheritdoc}
+ */
+ public function nextPlaceholder() {
+ // TODO: Implement nextPlaceholder() method.
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function isPrepared() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function preExecute(SelectInterface $query = NULL) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function where($snippet, $args = array()) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function extend($extender_name) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function &getExpressions() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function &getGroupBy() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function &getUnion() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function forUpdate($set = TRUE) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function rightJoin($table, $alias = NULL, $condition = NULL, $arguments = array()) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function &conditions() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function orderRandom() {
+ // We could implement this but why bother.
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function union(SelectInterface $query, $type = '') {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function addExpression($expression, $alias = NULL, $arguments = array()) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function &getTables() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getArguments(PlaceholderInterface $query_place_holder = NULL) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function &getOrderBy() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function &getFields() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function exists(SelectInterface $select) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function notExists(SelectInterface $select) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function arguments() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function compile(Connection $connection, PlaceholderInterface $query_place_holder) {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function compiled() {
+ throw new \Exception(sprintf('Method "%s" is not supported', __METHOD__));
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function getInfo() {
+ return array(
+ 'name' => 'Fake select test',
+ 'description' => 'Tests for fake select plugin.',
+ 'group' => 'Migrate',
+ );
+ }
+
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/FakeStatement.php b/core/modules/migrate/tests/Drupal/migrate/Tests/FakeStatement.php
new file mode 100644
index 000000000000..9088c50bd2ff
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/FakeStatement.php
@@ -0,0 +1,103 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\FakeStatement.
+ */
+
+namespace Drupal\migrate\Tests;
+
+use Drupal\Core\Database\StatementInterface;
+
+/**
+ * Represents a fake prepared statement.
+ */
+class FakeStatement extends \ArrayIterator implements StatementInterface {
+
+ /**
+ * {@inheritdoc}
+ */
+ public function execute($args = array(), $options = array()) {
+ throw new \Exception('This method is not supported');
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function getQueryString() {
+ throw new \Exception('This method is not supported');
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function rowCount() {
+ return $this->count();
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function fetchField($index = 0) {
+ $row = array_values($this->current());
+ $return = $row[$index];
+ $this->next();
+ return $return;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function fetchAssoc() {
+ $return = $this->current();
+ $this->next();
+ return $return;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function fetchCol($index = 0) {
+ $return = array();
+ foreach ($this as $row) {
+ $row = array_values($row);
+ $return[] = $row[$index];
+ }
+ return $return;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function fetchAllKeyed($key_index = 0, $value_index = 1) {
+ $return = array();
+ foreach ($this as $row) {
+ $row = array_values($row);
+ $return[$row[$key_index]] = $row[$value_index];
+ }
+ return $return;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public function fetchAllAssoc($key, $fetch = NULL) {
+ $return = array();
+ foreach ($this as $row) {
+ $return[$row[$key]] = $row;
+ }
+ return $return;
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function getInfo() {
+ return array(
+ 'name' => 'Fake statement test',
+ 'description' => 'Tests for fake statement plugin.',
+ 'group' => 'Migrate',
+ );
+ }
+
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/MigrateExecutableTest.php b/core/modules/migrate/tests/Drupal/migrate/Tests/MigrateExecutableTest.php
new file mode 100644
index 000000000000..295ed6dadee3
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/MigrateExecutableTest.php
@@ -0,0 +1,104 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\MigrateExecutableTest.
+ */
+
+namespace Drupal\migrate\Tests;
+
+use Drupal\Core\StringTranslation\TranslationInterface;
+use Drupal\migrate\Entity\MigrationInterface;
+use Drupal\migrate\MigrateExecutable;
+
+/**
+ * Tests the migrate executable.
+ *
+ * @group Drupal
+ * @group migrate
+ *
+ * @covers \Drupal\migrate\Tests\MigrateExecutableTest
+ */
+class MigrateExecutableTest extends MigrateTestCase {
+
+ /**
+ * The mocked migration entity.
+ *
+ * @var \Drupal\migrate\Entity\MigrationInterface|\PHPUnit_Framework_MockObject_MockObject
+ */
+ protected $migration;
+
+ /**
+ * The mocked migrate message.
+ *
+ * @var \Drupal\migrate\MigrateMessageInterface|\PHPUnit_Framework_MockObject_MockObject
+ */
+ protected $message;
+
+ /**
+ * The tested migrate executable.
+ *
+ * @var \Drupal\migrate\MigrateExecutable
+ */
+ protected $executable;
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function getInfo() {
+ return array(
+ 'name' => 'Migrate executable',
+ 'description' => 'Tests the migrate executable.',
+ 'group' => 'Migrate',
+ );
+ }
+
+ protected function setUp() {
+ $this->migration = $this->getMock('Drupal\migrate\Entity\MigrationInterface');
+ $this->message = $this->getMock('Drupal\migrate\MigrateMessageInterface');
+ $id_map = $this->getMock('Drupal\migrate\Plugin\MigrateIdMapInterface');
+
+ $this->migration->expects($this->any())
+ ->method('getIdMap')
+ ->will($this->returnValue($id_map));
+
+ $this->executable = new TestMigrateExecutable($this->migration, $this->message);
+ $this->executable->setTranslationManager($this->getStringTranslationStub());
+ }
+
+ /**
+ * Tests an import with an incomplete rewinding.
+ */
+ public function testImportWithFailingRewind() {
+ $iterator = $this->getMock('\Iterator');
+ $iterator->expects($this->once())
+ ->method('valid')
+ ->will($this->returnCallback(function() {
+ throw new \Exception('invalid source iteration');
+ }));
+ $source = $this->getMock('Drupal\migrate\Plugin\MigrateSourceInterface');
+ $source->expects($this->any())
+ ->method('getIterator')
+ ->will($this->returnValue($iterator));
+
+ $this->migration->expects($this->any())
+ ->method('getSourcePlugin')
+ ->will($this->returnValue($source));
+
+ // Ensure that a message with the proper message was added.
+ $this->message->expects($this->once())
+ ->method('display')
+ ->with('Migration failed with source plugin exception: invalid source iteration');
+
+ $result = $this->executable->import();
+ $this->assertEquals(MigrationInterface::RESULT_FAILED, $result);
+ }
+
+}
+
+class TestMigrateExecutable extends MigrateExecutable {
+
+ public function setTranslationManager(TranslationInterface $translation_manager) {
+ $this->translationManager = $translation_manager;
+ }
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/MigrateSqlSourceTestCase.php b/core/modules/migrate/tests/Drupal/migrate/Tests/MigrateSqlSourceTestCase.php
new file mode 100644
index 000000000000..145697762762
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/MigrateSqlSourceTestCase.php
@@ -0,0 +1,88 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\MigrateSqlSourceTestCase.
+ */
+
+namespace Drupal\migrate\Tests;
+
+/**
+ * Provides setup and helper methods for Migrate module source tests.
+ */
+abstract class MigrateSqlSourceTestCase extends MigrateTestCase {
+
+ /**
+ * The tested source plugin.
+ *
+ * @var \Drupal\migrate\Plugin\migrate\source\d6\Comment.
+ */
+ protected $source;
+
+ protected $databaseContents = array();
+
+ const PLUGIN_CLASS = '';
+
+ const ORIGINAL_HIGHWATER = '';
+
+ protected $expectedResults = array();
+
+ /**
+ * @var \Drupal\migrate\Plugin\MigrateSourceInterface
+ */
+ protected $plugin;
+
+ /**
+ * {@inheritdoc}
+ */
+ protected function setUp() {
+ $module_handler = $this->getMockBuilder('Drupal\Core\Extension\ModuleHandlerInterface')
+ ->disableOriginalConstructor()
+ ->getMock();
+
+ $migration = $this->getMigration();
+ $migration->expects($this->any())
+ ->method('getHighwater')
+ ->will($this->returnValue(static::ORIGINAL_HIGHWATER));
+ // Need the test class, not the original because we need a setDatabase method. This is not pretty :/
+ $plugin_class = preg_replace('/^(Drupal\\\\\w+\\\\)Plugin\\\\migrate(\\\\source(\\\\.+)?\\\\)([^\\\\]+)$/', '\1Tests\2Test\4', static::PLUGIN_CLASS);
+ $plugin = new $plugin_class($this->migrationConfiguration['source'], $this->migrationConfiguration['source']['plugin'], array(), $migration);
+ $plugin->setDatabase($this->getDatabase($this->databaseContents + array('test_map' => array())));
+ $plugin->setModuleHandler($module_handler);
+ $migration->expects($this->any())
+ ->method('getSourcePlugin')
+ ->will($this->returnValue($plugin));
+ $migrateExecutable = $this->getMockBuilder('Drupal\migrate\MigrateExecutable')
+ ->disableOriginalConstructor()
+ ->getMock();
+ $this->source = new TestSource($migration, $migrateExecutable);
+
+ $cache = $this->getMock('Drupal\Core\Cache\CacheBackendInterface');
+ $this->source->setCache($cache);
+ }
+
+ public function testRetrieval() {
+ $this->queryResultTest($this->source, $this->expectedResults);
+ }
+
+ /**
+ * @param \Drupal\migrate\Row $row
+ * @param string $key
+ * @return mixed
+ */
+ protected function getValue($row, $key) {
+ return $row->getSourceProperty($key);
+ }
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function getInfo() {
+ return array(
+ 'name' => 'SQL source test',
+ 'description' => 'Tests for SQL source plugin.',
+ 'group' => 'Migrate',
+ );
+ }
+
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/MigrateTestCase.php b/core/modules/migrate/tests/Drupal/migrate/Tests/MigrateTestCase.php
new file mode 100644
index 000000000000..7ca0ae6e93c6
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/MigrateTestCase.php
@@ -0,0 +1,141 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\MigrateTestCase.
+ */
+
+namespace Drupal\migrate\Tests;
+
+use Drupal\Tests\UnitTestCase;
+
+/**
+ * Provides setup and helper methods for Migrate module tests.
+ */
+abstract class MigrateTestCase extends UnitTestCase {
+
+ /**
+ * @TODO: does this need to be derived from the source/destination plugin?
+ *
+ * @var bool
+ */
+ protected $mapJoinable = TRUE;
+
+ protected $migrationConfiguration = array();
+
+ /**
+ * Retrieve a mocked migration.
+ *
+ * @return \Drupal\migrate\Entity\MigrationInterface
+ * The mocked migration.
+ */
+ protected function getMigration() {
+ $idmap = $this->getMock('Drupal\migrate\Plugin\MigrateIdMapInterface');
+ if ($this->mapJoinable) {
+ $idmap->expects($this->once())
+ ->method('getQualifiedMapTable')
+ ->will($this->returnValue('test_map'));
+ }
+
+ $migration = $this->getMock('Drupal\migrate\Entity\MigrationInterface');
+ $migration->expects($this->any())
+ ->method('getIdMap')
+ ->will($this->returnValue($idmap));
+ $configuration = $this->migrationConfiguration;
+ $migration->expects($this->any())->method('get')->will($this->returnCallback(function ($argument) use ($configuration) {
+ return isset($configuration[$argument]) ? $configuration[$argument] : '';
+ }));
+ $migration->expects($this->any())
+ ->method('id')
+ ->will($this->returnValue($configuration['id']));
+ return $migration;
+ }
+
+ /**
+ * @return \Drupal\Core\Database\Connection
+ */
+ protected function getDatabase($database_contents) {
+ $database = $this->getMockBuilder('Drupal\Core\Database\Connection')
+ ->disableOriginalConstructor()
+ ->getMock();
+ $database->databaseContents = &$database_contents;
+ $database->expects($this->any())
+ ->method('select')->will($this->returnCallback(function ($base_table, $base_alias) use ($database_contents) {
+ return new FakeSelect($base_table, $base_alias, $database_contents);
+ }));
+ $database->expects($this->any())
+ ->method('schema')
+ ->will($this->returnCallback(function () use (&$database_contents) {
+ return new FakeDatabaseSchema($database_contents);
+ }));
+ $database->expects($this->any())
+ ->method('insert')
+ ->will($this->returnCallback(function ($table) use (&$database_contents) {
+ return new FakeInsert($database_contents, $table);
+ }));
+ $database->expects($this->any())
+ ->method('update')
+ ->will($this->returnCallback(function ($table) use (&$database_contents) {
+ return new FakeUpdate($database_contents, $table);
+ }));
+ $database->expects($this->any())
+ ->method('merge')
+ ->will($this->returnCallback(function ($table) use (&$database_contents) {
+ return new FakeMerge($database_contents, $table);
+ }));
+ $database->expects($this->any())
+ ->method('query')
+ ->will($this->throwException(new \Exception('Query is not supported')));
+ return $database;
+ }
+
+ /**
+ * Tests a query
+ *
+ * @param array|\Traversable
+ * The countable. foreach-able actual results if a query is being run.
+ */
+ public function queryResultTest($iter, $expected_results) {
+ $this->assertSame(count($expected_results), count($iter), 'Number of results match');
+ $count = 0;
+ foreach ($iter as $data_row) {
+ $expected_row = $expected_results[$count];
+ $count++;
+ foreach ($expected_row as $key => $expected_value) {
+ $this->retrievalAssertHelper($expected_value, $this->getValue($data_row, $key), sprintf('Value matches for key "%s"', $key));
+ }
+ }
+ $this->assertSame(count($expected_results), $count);
+ }
+
+ /**
+ * @param array $row
+ * @param string $key
+ * @return mixed
+ */
+ protected function getValue($row, $key) {
+ return $row[$key];
+ }
+
+ /**
+ * Asserts tested values during test retrieval.
+ *
+ * @param mixed $expected_value
+ * The incoming expected value to test.
+ * @param mixed $actual_value
+ * The incoming value itself.
+ * @param string $message
+ * The tested result as a formatted string.
+ */
+ protected function retrievalAssertHelper($expected_value, $actual_value, $message) {
+ if (is_array($expected_value)) {
+ foreach ($expected_value as $k => $v) {
+ $this->retrievalAssertHelper($v, $actual_value[$k], $message . '['. $k . ']');
+ }
+ }
+ else {
+ $this->assertSame((string) $expected_value, (string) $actual_value, $message);
+ }
+ }
+
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/TestSource.php b/core/modules/migrate/tests/Drupal/migrate/Tests/TestSource.php
new file mode 100644
index 000000000000..99988d6d6fb6
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/TestSource.php
@@ -0,0 +1,18 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\TestSource.
+ */
+
+
+namespace Drupal\migrate\Tests;
+
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\migrate\Source;
+
+class TestSource extends Source {
+ function setCache(CacheBackendInterface $cache) {
+ $this->cache = $cache;
+ }
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/process/GetTest.php b/core/modules/migrate/tests/Drupal/migrate/Tests/process/GetTest.php
new file mode 100644
index 000000000000..e49e1f2cc5c4
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/process/GetTest.php
@@ -0,0 +1,90 @@
+<?php
+/**
+ * @file
+ * Contains
+ */
+
+namespace Drupal\migrate\Tests\process;
+
+use Drupal\migrate\Plugin\migrate\process\TestGet;
+
+/**
+ * @group migrate
+ * @group Drupal
+ */
+class GetTest extends MigrateProcessTestCase {
+
+ /**
+ * {@inheritdoc}
+ */
+ public static function getInfo() {
+ return array(
+ 'name' => 'Get process plugin',
+ 'description' => 'Tests the get process plugin.',
+ 'group' => 'Migrate',
+ );
+ }
+
+ function setUp() {
+ $this->plugin = new TestGet();
+ parent::setUp();
+ }
+
+ function testTransformSourceString() {
+ $this->row->expects($this->once())
+ ->method('getSourceProperty')
+ ->with('test')
+ ->will($this->returnValue('source_value'));
+ $this->plugin->setSource('test');
+ $value = $this->plugin->transform(NULL, $this->migrateExecutable, $this->row, 'destinationproperty');
+ $this->assertSame($value, 'source_value');
+ }
+
+ function testTransformSourceArray() {
+ $map = array(
+ 'test1' => 'source_value1',
+ 'test2' => 'source_value2',
+ );
+ $this->plugin->setSource(array('test1', 'test2'));
+ $this->row->expects($this->exactly(2))
+ ->method('getSourceProperty')
+ ->will($this->returnCallback(function ($argument) use ($map) { return $map[$argument]; } ));
+ $value = $this->plugin->transform(NULL, $this->migrateExecutable, $this->row, 'destinationproperty');
+ $this->assertSame($value, array('source_value1', 'source_value2'));
+ }
+
+ function testTransformSourceStringAt() {
+ $this->row->expects($this->once())
+ ->method('getSourceProperty')
+ ->with('@test')
+ ->will($this->returnValue('source_value'));
+ $this->plugin->setSource('@@test');
+ $value = $this->plugin->transform(NULL, $this->migrateExecutable, $this->row, 'destinationproperty');
+ $this->assertSame($value, 'source_value');
+ }
+
+ function testTransformSourceArrayAt() {
+ $map = array(
+ 'test1' => 'source_value1',
+ '@test2' => 'source_value2',
+ '@test3' => 'source_value3',
+ 'test4' => 'source_value4',
+ );
+ $this->plugin->setSource(array('test1', '@@test2', '@@test3', 'test4'));
+ $this->row->expects($this->exactly(4))
+ ->method('getSourceProperty')
+ ->will($this->returnCallback(function ($argument) use ($map) { return $map[$argument]; } ));
+ $value = $this->plugin->transform(NULL, $this->migrateExecutable, $this->row, 'destinationproperty');
+ $this->assertSame($value, array('source_value1', 'source_value2', 'source_value3', 'source_value4'));
+ }
+}
+
+namespace Drupal\migrate\Plugin\migrate\process;
+
+class TestGet extends Get {
+ function __construct() {
+ }
+ function setSource($source) {
+ $this->configuration['source'] = $source;
+ }
+}
diff --git a/core/modules/migrate/tests/Drupal/migrate/Tests/process/MigrateProcessTestCase.php b/core/modules/migrate/tests/Drupal/migrate/Tests/process/MigrateProcessTestCase.php
new file mode 100644
index 000000000000..d99a865b2ab2
--- /dev/null
+++ b/core/modules/migrate/tests/Drupal/migrate/Tests/process/MigrateProcessTestCase.php
@@ -0,0 +1,39 @@
+<?php
+
+/**
+ * @file
+ * Contains \Drupal\migrate\Tests\process\MigrateProcessTestCase.
+ */
+
+namespace Drupal\migrate\Tests\process;
+
+use Drupal\migrate\Tests\MigrateTestCase;
+
+abstract class MigrateProcessTestCase extends MigrateTestCase {
+
+ /**
+ * @var \Drupal\migrate\Plugin\migrate\process\TestGet
+ */
+ protected $plugin;
+
+ /**
+ * @var \Drupal\migrate\Row
+ */
+ protected $row;
+
+ /**
+ * @var \Drupal\migrate\MigrateExecutable
+ */
+ protected $migrateExecutable;
+
+ function setUp() {
+ $this->row = $this->getMockBuilder('Drupal\migrate\Row')
+ ->disableOriginalConstructor()
+ ->getMock();
+ $this->migrateExecutable = $this->getMockBuilder('Drupal\migrate\MigrateExecutable')
+ ->disableOriginalConstructor()
+ ->getMock();
+ parent::setUp();
+ }
+
+}
--
GitLab