class MigrateListFiles in Migrate 7.2

Implementation of MigrateList, for retrieving a list of IDs to be migrated from a directory listing. Each item is a file, it's ID is the path.

If individual files contain more than one source, use a MigrateContentParser to parse the file and split it into chunks.

Hierarchy

• class \MigrateList
  • class \MigrateListFiles

File

plugins/sources/files.inc, line 120

Support for migration from files sources.

class MigrateListFiles extends MigrateList {
  protected $listDirs;
  protected $baseDir;
  protected $fileMask;
  protected $directoryOptions;
  protected $parser;
  protected $getContents;

  /**
   * Constructor.
   *
   * @param $list_dirs
   *   Array of directory paths that will be scanned for files. No trailing
   *   slash. For example:
   *     array(
   *       '/var/html_source/en/news',
   *       '/var/html_source/fr/news',
   *       '/var/html_source/zh/news',
   *     );
   * @param $base_dir
   *   The base dir is the part of the path that will be excluded when making
   *   an ID for each file. To continue the example from above, you want
   *   base_dir to be = '/var/html_source', so that the files will have IDs in
   *   the format
   *   '/en/news/news_2011_03_4.html'.
   * @param $file_mask
   *   (optional) Passed on and used to filter for certain types of files. Use
   *   a
   *   regular expression, for example '/(.*\.htm$|.*\.html$)/i' to match all
   *   .htm and .html files, case insensitive. Defaults to matching all files.
   * @param $options
   *   Options that will be passed on to file_scan_directory(). See docs of
   *   that
   *   core Drupal function for more information.
   * @param MigrateContentParser $parser
   *   Content parser class to use.
   * @param $get_contents
   *   Whether to load the contents of files.
   */
  public function __construct($list_dirs, $base_dir, $file_mask = '//', $options = array(), MigrateContentParser $parser = NULL, $get_contents = TRUE) {
    if (!$parser) {
      $parser = new MigrateSimpleContentParser();
    }
    parent::__construct();
    $this->listDirs = $list_dirs;
    $this->baseDir = $base_dir;
    $this->fileMask = $file_mask;
    $this->directoryOptions = $options;
    $this->parser = $parser;
    $this->getContents = $get_contents;
  }

  /**
   * Our public face is the directories we're getting items from.
   */
  public function __toString() {
    if (is_array($this->listDirs)) {
      return implode(',', $this->listDirs);
    }
    else {
      return $this->listDirs;
    }
  }

  /**
   * Retrieve a list of files based on parameters passed for the migration.
   */
  public function getIdList() {
    $files = array();
    foreach ($this->listDirs as $dir) {
      migrate_instrument_start("Retrieve {$dir}");
      $files = array_merge(file_scan_directory($dir, $this->fileMask, $this->directoryOptions), $files);
      migrate_instrument_stop("Retrieve {$dir}");
    }
    if (isset($files)) {
      return $this
        ->getIDsFromFiles($files);
    }
    Migration::displayMessage(t('Loading of !listuri failed:', array(
      '!listuri' => $this->listUri,
    )));
    return NULL;
  }

  /**
   * Given an array generated from file_scan_directory(), parse out the IDs for
   * processing and return them as an array.
   */
  protected function getIDsFromFiles(array $files) {
    $ids = array();
    foreach ($files as $file) {
      $file_base_id = str_replace($this->baseDir, '', (string) $file->uri);
      if ($this->getContents) {
        $contents = file_get_contents($file->uri);
        $this->parser
          ->setContent($contents, $file_base_id);
        if ($this->parser->alwaysUseChunkIDs || $this->parser
          ->getChunkCount() > 1) {
          foreach ($this->parser
            ->getChunkIDs() as $chunk_id) {
            $ids[] = $file_base_id . MIGRATE_CHUNK_SEPARATOR . $chunk_id;
          }
        }
        else {
          $ids[] = $file_base_id;
        }
      }
      else {
        $ids[] = $file_base_id;
      }
    }
    return array_unique($ids);
  }

  /**
   * Return a count of all available IDs from the source listing.
   */
  public function computeCount() {
    $count = 0;
    $files = $this
      ->getIdList();
    if ($files) {
      $count = count($files);
    }
    return $count;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
MigrateListFiles::$baseDir	protected	property
MigrateListFiles::$directoryOptions	protected	property
MigrateListFiles::$fileMask	protected	property
MigrateListFiles::$getContents	protected	property
MigrateListFiles::$listDirs	protected	property
MigrateListFiles::$parser	protected	property
MigrateListFiles::computeCount	public	function	Return a count of all available IDs from the source listing. Overrides MigrateList::computeCount
MigrateListFiles::getIdList	public	function	Retrieve a list of files based on parameters passed for the migration. Overrides MigrateList::getIdList
MigrateListFiles::getIDsFromFiles	protected	function	Given an array generated from file_scan_directory(), parse out the IDs for processing and return them as an array.
MigrateListFiles::__construct	public	function	Constructor. Overrides MigrateList::__construct
MigrateListFiles::__toString	public	function	Our public face is the directories we're getting items from. Overrides MigrateList::__toString