Club Drupal

Feeds 7.x 2.0 Beta 4, 2017-09-24

--------------------------------

- Issue #2911282 by MegaChriz: Fixed do not show bundle warning for non-entity

  processors.

- Issue #2911281 by MegaChriz: changed messages related to rescheduling imports.

- Issue #2879005 by MegaChriz, anup.singh: fixed array_flip() notice that

  occurred when mapping a float value to node author.

- Issue #1962006 by MegaChriz, gordon, twistor: Added hook

  hook_feeds_config_defaults() to allow other modules to add extra

  configuration.

- Issue #2884308 by ppavels: Fixed import links in admin menu for feed importers

  that are attached to a content type which name contains underscores.

- Issue #1360910 by MegaChriz, leendertdb: Added an option for the HTTP Fetcher

  to disable caching content fetched via HTTP.

- Issue #2877125 by MegaChriz: Replaced http_request_get() with

  feeds_http_request() in order to easier implement more options for HTTP

  requests.

- Issue #2662892 by MegaChriz: Do not cache downloaded source statically to

  improve PHP memory usage.

- Issue #2854548 by MegaChriz: Don't display a warning about "Attach to content

  type" setting being the same as the node processor's content type when the

  importer is not attached to a content type.

- Issue #2854548 by MegaChriz: Added warning when user has the "Attach to

  content type" setting the same as the node processor's content type.

- Issue #2445477 by MegaChriz: Added validation for combination of settings that

  causes the "Process in background" setting to have no effect.

- Issue #2630694 by MegaChriz, twistor: Run background jobs directly in queue.

- Issue #2868134 by MegaChriz: Show next time that the source will be imported.

- Issue #2450365 by MegaChriz, twistor, littledynamo: Fixed importer is not

  rescheduled for new sources when using attach to node.

- Issue #2871580 by MegaChriz: Fixed jobs for no longer existing feeds are kept

  being scheduled.

- Issue #2871583 by MegaChriz: Fixed feeds jobs are not cleaned up when

  uninstalling Feeds.

- Issue #2866377 by permanovd, MegaChriz: Fixed release file handle on

  exception.

- Issue #2320781 by MegaChriz: Added validation for feed importer configuration:

  check for invalid bundle and invalid language.

- Issue #2839706 by wmostrey, MegaChriz: Allow Feeds Importers to be edited even

  when disabled.

- Issue #2867182 by MegaChriz: Added a finishImport() method to FeedsSource to

  bundle tasks that need to be done at the end of an import.

- Issue #2867189 by MegaChriz: Added a method to FeedsSource to unlock a feed.

- Issue #2087091 by MegaChriz: Fixed clear states properly after import.

- Issue #2829097 by MegaChriz: fixed don't store raw source in feeds_source

  table.

- Issue #2863209 by MegaChriz: fixed class 'FeedsHTTPCache' not found in

  _cache_get_object() during/after performing database updates.

- Issue #2860047 by skessler, MegaChriz: Fixed link to feeds log page in

  watchdog call.

- Issue #2847312 by mikran, MegaChriz: Added entity metadata properties for

  feeds_item GUID and URL.

- Issue #2788125 by MegaChriz, PaulDinelle: Added support for i18n_node bundle

  language settings.

- Issue #2857935 by MegaChriz: Fixed failing test

  FeedsMapperMultilingualFieldsTestCase::testChangedLanguageImportForExistingNode().

- Issue #2854152 by renatog, MegaChriz: Delete feeds variables when uninstalling

  Feeds.

- Issue #2851707 by MegaChriz: Added user validation.

- Issue #2752661 by MegaChriz, geru: build the list of available sources and

  targets in feeds_ui_mapping_form() instead of in the theme function, so Feeds

  Tamper can alter the form to fix the bug of temporary targets not showing in

  the UI.

- Issue #1037188 by saurabh.tripathi.cs, msti, MegaChriz, twistor: Log

  exceptions that are thrown when trying to fetch from a HTTP source.

- Issue #2829096 by MegaChriz: Cache result of HTTP source on file system.

- Issue #2828605 by David_Rothstein: fixed "The following module has moved

  within the file system" warning that occurred when downloading or enabling a

  new module or when enabling a previously installed module that was moved on

  the file system.

- Issue #2762339 by MegaChriz: fixed feed node form inherits settings from the

  standalone importer when switching from standalone to attach to content type.

- Issue #2839464 by MegaChriz: improved error message for when a download from a

  url fails.

- Issue #2379631 by MegaChriz, cboyden, twistor, joelpittet, robhardwick,

  dsnopek: fixed field_attach_validate() must be called before programmatic

  entity saves.

- Issue #2445997 by MegaChriz: fixed do not load all Feeds plugins in

  feeds_forms() when no Feeds form is requested.

- Issue #2838283 by MegaChriz: Fixed failing test

  FeedsMapperDateMultipleTestCase::test().

- Issue #2834026 by bburg, MegaChriz: Fixed do not add blank column headers in

  CSV template.

  FeedsSource->scheduleClear()

Running the Drush integration tests

===================================

In order the run Drush integration tests, Drush itself needs to be installed

with its *dev dependencies*. Furthermore, the phpunit version that comes with

Drush should be used for running the tests (instead of a globally installed

phpunit), as that one has proven to be compatible with the Drush tests.

  1. Git clone of Drush 8.

       git clone --branch 8.x https://github.com/drush-ops/drush.git

       cd drush

  2. Install Drush with dev dependencies using Composer.

       composer install

     And ensure that the following text is displayed:

       "Loading composer repositories with package information

       Installing dependencies (including require-dev) from lock file"

     Especially note that Composer says 'including require-dev'. This means that

     the Drush dev dependencies are installed (including phpunit).

  3. Execute a command like the following:

       UNISH_NO_TIMEOUTS=1 UNISH_DRUPAL_MAJOR_VERSION=7 /path/to/drush/vendor/bin/phpunit --configuration /path/to/drush/tests /path/to/feeds/tests/drush

     Replace '/path/to' with the appropriate path to the directory in question.

     Also be sure to point to the phpunit version that comes with Drush.

     So if Drush is installed in /users/megachriz/drush and the Feeds module is

     located at /users/megachriz/Sites/drupal7/sites/all/modules/feeds:

       UNISH_NO_TIMEOUTS=1 UNISH_DRUPAL_MAJOR_VERSION=7 /users/megachriz/drush/vendor/bin/phpunit --configuration /users/megachriz/drush/tests /users/megachriz/Sites/drupal7/sites/all/modules/feeds/tests/drush

Name:        feeds_http_file_cache_dir

Default:     private://feeds/cache

Description: The location on the file system where results of HTTP requests are

             cached.

Name:        feeds_in_progress_dir

Default:     private://feeds/in_progress

Description: The location on the file system where temporary files are stored

             that are in progress of being imported.

Name:        feeds_sync_cache_feeds_http_interval

Default:     21600

Description: How often the feeds cache directory should be checked for orphaned

             cache files.

/**

 * This hooks allows you add additional configuration keys to a

 * FeedsConfigurable.

 *

 * @param FeedsConfigurable $configurable

 *   The configurable item to add default configuration to.

 *

 * @return array

 *   Return an array of default configuration.

 */

function hook_feeds_config_defaults(FeedsConfigurable $configurable) {

  if ($configurable instanceof FeedsImporter) {

    return array(

      'my_module_extra_setting_1' => 0,

      'my_module_extra_setting_2' => NULL,

    );

  }

}

/**

 * A plugin-specific hook to add additional configuration keys instead of the

 * global hook_feeds_config_defaults().

 *

 * The plugin type can be:

 * - fetcher

 * - parser

 * - processor

 *

 * @param FeedsPlugin $plugin

 *   The plugin to add default configuration to.

 *

 * @return array

 *   Return an array of default configuration.

 */

function hook_feeds_PLUGIN_TYPE_config_defaults(FeedsPlugin $plugin) {

  if ($plugin instanceof FeedsCSVParser) {

    return array(

      'extra_csv_parser_setting' => NULL,

    );

  }

}

      drush_set_error(dt("The importer '@importer' does not exist.", array(

    elseif (!$importer->isEnabled()) {

      drush_set_error(dt("The importer '@importer' is not enabled. You can enable it with the command '@command'.", array(

        '@importer' => $importer_id,

        '@command' => 'drush feeds-enable ' . $importer_id,

      )));

      return FALSE;

    }

      drush_set_error(dt("The importer '@importer' does not exist.", array(

        '@importer' => $importer_id,

      )));

      return FALSE;

    }

    elseif (!$importer->isEnabled()) {

      drush_set_error(dt("The importer '@importer' is not enabled. You can enable it with the command '@command'.", array(

        '@command' => 'drush feeds-enable ' . $importer_id,

files[] = includes/FeedsHTTPCache.inc

files[] = includes/FeedsHTTPCacheItem.inc

files[] = tests/feeds_entity.test

files[] = tests/feeds_hooks.test

files[] = tests/feeds_install.test

files[] = tests/FeedsEnclosureTest.test

files[] = tests/FeedsFetcherResultTest.test

files[] = tests/FeedsHTTPCacheTest.test

files[] = tests/FeedsSourceTest.test

; Information added by Drupal.org packaging script on 2017-09-24

version = "7.x-2.0-beta4"

datestamp = "1506257048"

 * Implements hook_install().

 */

function feeds_install() {

  // Activate our custom cache handler for the HTTP cache.

  variable_set('cache_class_cache_feeds_http', 'FeedsHTTPCache');

}

/**

 * Implements hook_uninstall().

 */

  variable_del('cache_class_cache_feeds_http');

  variable_del('cache_flush_cache_feeds_http');

  variable_del('default_feeds_importer');

  variable_del('feeds_debug');

  variable_del('feeds_http_file_cache_dir');

  variable_del('feeds_importer_class');

  variable_del('feeds_in_progress_dir');

  variable_del('feeds_library_dir');

  variable_del('feeds_never_use_curl');

  variable_del('feeds_process_limit');

  variable_del('feeds_source_class');

  variable_del('feeds_sync_cache_feeds_http_interval');

  variable_del('feeds_sync_cache_feeds_http_last_check');

  variable_del('http_request_timeout');

  // Remove Feeds related jobs from job scheduler.

  $names = db_or()

    ->condition('name', 'feeds_source_import')

    ->condition('name', 'feeds_source_clear')

    ->condition('name', 'feeds_source_expire')

    ->condition('name', 'feeds_push_unsubscribe');

  db_delete('job_schedule')

    ->condition($names)

    ->execute();

/**

 * Set cache class for Feeds HTTP cache.

 */

function feeds_update_7213() {

  // Perform a registry rebuild so the system hopefully discovers the

  // FeedsHTTPCache class.

  if (function_exists('registry_rebuild')) {

    registry_rebuild();

  }

  // Abort when the FeedsHTTPCache class is not yet found to avoid fatal errors

  // in _cache_get_object().

  if (!class_exists('FeedsHTTPCache')) {

    throw new DrupalUpdateException('Setting the cache class for the cache_feeds_http bin failed because the FeedsHTTPCache class could not be found. Please rebuild the Drupal class registry and perform database updates again.');

  }

  // Activate our custom cache handler for the HTTP cache.

  variable_set('cache_class_cache_feeds_http', 'FeedsHTTPCache');

}

    'feeds_config_defaults',

    'feeds_fetcher_config_defaults',

    'feeds_parser_config_defaults',

    'feeds_processor_config_defaults',

  $importers = feeds_reschedule();

  if ($importers) {

    // @todo Maybe we should queue this somehow as well. This could be potentially

    // very long.

    $sources = db_query("SELECT feed_nid, id FROM {feeds_source} WHERE id IN (:ids)", array(':ids' => $importers));

    foreach ($sources as $source) {

      feeds_source($source->id, $source->feed_nid)->schedule();

    }

    feeds_reschedule(FALSE);

  // Sync the files in the cache directory with entries in the cache every now

  // and then. By default: every six hours.

  $last_check = variable_get('feeds_sync_cache_feeds_http_last_check');

  $interval = variable_get('feeds_sync_cache_feeds_http_interval', 21600);

  if ($last_check < (REQUEST_TIME - $interval)) {

    // Check first if the task isn't already queued.

    $queue = DrupalQueue::get('feeds_sync_cache_feeds_http');

    if ($queue->numberOfItems() < 1) {

      // Queue sync task.

      FeedsHTTPCache::getInstance('cache_feeds_http')->startSync();

    }

    variable_set('feeds_sync_cache_feeds_http_last_check', REQUEST_TIME);

  }

  // feeds_source_clear never gets called, since we now use the queue directly.

  // This is left in case any background jobs still running after an

  // upgrade.

  $queues['feeds_sync_cache_feeds_http'] = array(

    'worker callback' => 'feeds_sync_cache_feeds_http',

  );

  if ($source->doesExist()) {

    $source->scheduleImport();

  }

  if ($source->doesExist()) {

    $source->scheduleClear();

  }

  if ($source->doesExist()) {

    $source->scheduleExpire();

  }

    // Eventually remove the job from job scheduler.

    JobScheduler::get('feeds_source_import')->remove($job);

/**

 * Scheduler callback for syncing the feeds cache directory with the entries in

 * the cache.

 */

function feeds_sync_cache_feeds_http(array $job) {

  FeedsHTTPCache::getInstance('cache_feeds_http')->sync($job['files']);

}

function feeds_forms($form_id, $args) {

  // Check if the requested form is a Feeds form.

  if (!stripos($form_id, '_feeds_form')) {

    return;

  }

    $importer = feeds_importer($id);

    if ($importer->doesExist()) {

      return $importer;

    }

    watchdog('feeds', 'Feeds reported errors, visit the Feeds log for details.', array(), WATCHDOG_ERROR, l(t('view'), 'admin/reports/feeds'));

    $source->addConfig($node->feeds);

    $source->save();

    $source->ensureSchedule();

    $source = feeds_source($importer_id, empty($form['#node']->nid) ? NULL : $form['#node']->nid);

  if ($type !== 'module' || !module_exists($file->name) || !module_hook($file->name, 'feeds_plugins')) {

      '#href' => !empty($importer->config['content_type']) ? 'node/add/' . str_replace('_', '-', $importer->config['content_type']) : 'import/' . check_plain($importer->id),

    $info[$entity_type]['properties']['feeds_item_guid'] = array(

      'label' => 'Feeds Item GUID',

      'type' => 'text',

      'description' => t('Feeds Item GUID.'),

      'getter callback' => 'feeds_get_feeds_item_property',

    );

    $info[$entity_type]['properties']['feeds_item_url'] = array(

      'label' => 'Feeds Item URL',

      'type' => 'text',

      'description' => t('Feeds Item URL.'),

      'getter callback' => 'feeds_get_feeds_item_property',

    );

      'getter callback' => 'feeds_get_feeds_item_property',

      'getter callback' => 'feeds_get_feeds_item_property',

 * Entity API getter callback for getting a feeds_item property on an entity.

 *

 * @param object $entity

 *   An entity object.

 * @param array $options

 *   Options are ignored, but it is a param that is given by the Entiy API.

 * @param string $name

 *   The name of the property to get.

 * @param string $entity_type

 *   The entity's type.

 *

 * @return mixed

 *   The feeds_item property.

 */

function feeds_get_feeds_item_property($entity, array $options, $name, $entity_type) {

  // Map property name to actual feeds_item column.

  $property_map = array(

    'feed_node' => 'feed_nid',

    'feed_nid' => 'feed_nid',

    'feeds_item_guid' => 'guid',

    'feeds_item_url' => 'url',

  );

  $property_name = $property_map[$name];

  // First check if the entity has already the feeds item loaded with the

  // requested property and return its value if it does.

  if (isset($entity->feeds_item->$property_name)) {

    return $entity->feeds_item->$property_name;

  }

  // No feed item. Try to load the feed item if the entity has an ID.

  list($entity_id, , ) = entity_extract_ids($entity_type, $entity);

    $feeds_item = feeds_item_info_load($entity_type, $entity_id);

    // Check again for the requested property and return its value if it exists.

    if (isset($feeds_item->$property_name)) {

      return $feeds_item->$property_name;

  // Set submit button label based on settings.

  if ($source->importer->config['import_on_create']) {

    $submit = t('Import');

    if ($source->importer->config['process_in_background']) {

      // When processing the import in background, the import job is put in the queue.

      $submit = t('Schedule import');

    }

  }

  elseif ($source->importer->config['import_period'] != FEEDS_SCHEDULE_NEVER) {

    // The import would be scheduled according to the periodic import setting.

    $submit = t('Schedule import');

  }

  else {

    drupal_set_message(t('For this importer both "@import_period" and "@import_on_create" are turned off. It is possible that Feeds will not import the provided source.', array(

      '@import_period' => t('Periodic import'),

      '@import_on_create' => t('Import on submission'),

    )), 'warning', FALSE);

    $submit = t('Save');

  }

    '#value' => $submit,

  // Disable submit button if import is initiated.

    // Check if import task is queued.

    if ($source->isQueued()) {

      $form['source_status']['#value'] .= t('Run cron to continue the import.');

    }

    if ($source->importer->config['process_in_background']) {

      drupal_set_message(t('Import scheduled.'));

    }

  $source->ensureSchedule();

  // If an import is only triggered by periodic import, check if it is about to

  // be rescheduled so there is at least a message.

  if (!$source->importer->config['import_on_create']) {

    // Check if the importer is about to be rescheduled.

    $importers = feeds_reschedule();

    if (isset($importers[$form['#importer_id']])) {

      drupal_set_message(t('Rescheduling the import will happen on the next cron run.'), 'status');

    }

  }

  // Change submit button label if processing in background.

  if ($source->importer->config['process_in_background']) {

    $form['actions']['submit']['#value'] = t('Schedule import');

  }

  // Disable submit button if import is initiated.

    // Check if import task is queued.

    if ($source->isQueued()) {

      $form['source_status']['#value'] .= t('Run cron to continue the import.');

    }

  $source = feeds_source($form['#importer_id'], $form['#feed_nid']);

  $source->startImport();

  $source->ensureSchedule();

  if ($source->importer->config['process_in_background']) {

    drupal_set_message(t('Import scheduled.'));

  }

  // Change submit button label if processing in background.

  if ($source->importer->config['process_in_background']) {

    $form['actions']['submit']['#value'] = t('Schedule delete');

  }

  // Disable submit button if clearing is initiated.

    $form['source_status']['#value'] .= t('Run cron to continue the deletion of items.');

  $source = feeds_source($form['#importer_id'], $feed_nid);

  $source->startClear();

  $source->ensureSchedule();

  if ($source->importer->config['process_in_background']) {

    drupal_set_message(t('Deletion of items scheduled.'));

  }

  feeds_source($importer_id, $feed_nid)

    ->unlock();

  drupal_set_message(t('Importer unlocked.'));

  $v['next'] = $source->getNextImportTimeDetails();

  if ($v['next']) {

    // Check if medium date format contains hours/minutes.

    $date_format = variable_get('date_format_medium');

    $use_custom_date_format = $date_format && !strpos($date_format, 'H:i');

    if (!empty($v['next']['message'])) {

      $items[] = t('Next import: @message.', array(

        '@message' => $v['next']['message'],

      ));

    }

    elseif ($v['next']['time'] > REQUEST_TIME) {

      $items[] = t('Next import: @date (via @method)', array(

        '@date' => $use_custom_date_format ? format_date($v['next']['time'], 'custom', 'Y/m/d H:i:s') : format_date($v['next']['time']),

        '@method' => $v['next']['method'],

      ));

    }

    else {

      $items[] = t('Next import: on next cron run (via @method).', array(

        '@method' => $v['next']['method'],

      ));

    }

  }

  else {

    $items[] = t('Next import: not scheduled.');

  }

; Information added by Drupal.org packaging script on 2017-09-24

version = "7.x-2.0-beta4"

datestamp = "1506257048"

; Information added by Drupal.org packaging script on 2017-09-24

version = "7.x-2.0-beta4"

datestamp = "1506257048"

  // Validate configuration.

  $errors = $importer->validateConfig();

  if (count($errors)) {

    $message = t('There are some issues with the importer configuration: !errors', array(

      '!errors' => theme('item_list', array('items' => $errors)),

    ));

    drupal_set_message($message, 'warning');

  }

  $form['#feeds_targets'] = $importer->processor->getMappingTargets();

  $form['#feeds_sources'] = $importer->parser->getMappingSources();

  $targets = $form['#feeds_targets'];

  $sources = $form['#feeds_sources'];

    $errors = array();

    $importer = feeds_importer($feeds_importer->id);

    $importer->setConfig($feeds_importer->config);

      if (!($plugin instanceof FeedsMissingPlugin)) {

        $importer->setPlugin($feeds_importer->config[$type]['plugin_key']);

        $importer->$type->setConfig($feeds_importer->config[$type]['config']);

    $errors = array_merge($errors, $importer->validateConfig());

    if (!empty($errors)) {

      form_error($form['importer'], theme('item_list', array('items' => $errors)));

    }

; Information added by Drupal.org packaging script on 2017-09-24

version = "7.x-2.0-beta4"

datestamp = "1506257048"

    parent::setUp(array('php', 'locale'), array('use PHP for settings', 'administer languages'));

  }

  /**

   * UI functionality tests on disabled feeds.

   */

  public function testEditDisabledImporter() {

    // Create an importer.

    $this->createImporterConfiguration('Test feed', 'test_feed');

    // Disable the importer.

    $edit = array(

      'test_feed' => FALSE,

    );

    $this->drupalPost('admin/structure/feeds', $edit, t('Save'));

    // Try to edit the importer.

    $this->doEditFeedsConfiguration('Test feed', 'test_feed');

    // Try to edit the importer.

    $this->doEditFeedsConfiguration('Test feed', 'test_feed');

    // Check if importer is available on /import.

  /**

   * Tests if the user is warned when an invalid plugin is used.

   */

  public function testInvalidPlugin() {

    // Create an importer.

    $this->createImporterConfiguration('Test feed', 'test_feed');

    // Assert that there is no error message yet.

    $this->drupalGet('admin/structure/feeds/test_feed');

    $this->assertNoText('There are some issues with the importer configuration');

    // Add invalid fetcher plugin.

    $invalid_plugin = $this->randomName();

    $importer = feeds_importer('test_feed');

    $importer->addConfig(array(

      'fetcher' => array(

        'plugin_key' => $invalid_plugin,

        'config' => array(),

      ),

    ));

    $importer->save();

    // Assert error message on importer page.

    $this->drupalGet('admin/structure/feeds/test_feed');

    $this->assertText(format_string('The plugin @invalid_plugin is unavailable.', array(

      '@invalid_plugin' => $invalid_plugin,

    )));

  }

  /**

   * Tests if the user is warned when an invalid bundle is selected.

   */

  public function testInvalidBundle() {

    // Create an importer.

    $this->createImporterConfiguration('Test feed', 'test_feed');

    // Set invalid bundle.

    $invalid_bundle = drupal_strtolower($this->randomName());

    $importer = feeds_importer('test_feed');

    $importer->processor->addConfig(array(

      'bundle' => $invalid_bundle,

    ));

    $importer->save();

    // Assert error message on processor settings page.

    $this->drupalGet('admin/structure/feeds/test_feed/settings/FeedsNodeProcessor');

    $this->assertText(format_string('Invalid value @invalid_bundle for config option Bundle.', array(

      '@invalid_bundle' => $invalid_bundle,

    )));

    // But the option should still be selected.

    $this->assertFieldByName('bundle', $invalid_bundle);

  }

  /**

   * Tests if the user is warned when an invalid language is selected.

   */

  public function testInvalidLanguage() {

    // Add the Dutch language.

    $edit = array(

      'langcode' => 'nl',

    );

    $this->drupalPost('admin/config/regional/language/add', $edit, t('Add language'));

    // Create an importer.

    $this->createImporterConfiguration('Test feed', 'test_feed');

    // Change processor's language to Dutch.

    $this->setSettings('test_feed', 'FeedsNodeProcessor', array('language' => 'nl'));

    // Assert that there is no error message yet.

    $this->assertNoText('There are some issues with the importer configuration');

    // Now remove the Dutch language.

    $path = 'admin/config/regional/language/delete/nl';

    $this->drupalPost($path, array(), t('Delete'));

    // Assert error message on processor settings page.

    $this->drupalGet('admin/structure/feeds/test_feed/settings/FeedsNodeProcessor');

    $this->assertText(format_string('Invalid value @invalid_lang for config option Language.', array(

      '@invalid_lang' => 'nl',

    )));

    // But the option should still be selected.

    $this->assertFieldByName('language', 'nl');

  }

  /**

   * Tests if the user is warned when having both "Import on submission" and

   * "Periodic import" turned off.

   */

  public function testWarningPeriodicImportAndImportOnSubmissionTurnedOff() {

    // Create an importer.

    $this->createImporterConfiguration('Test feed', 'test_feed');

    $this->setSettings('test_feed', NULL, array(

      'content_type' => '',

      'import_period' => FEEDS_SCHEDULE_NEVER,

      'import_on_create' => FALSE,

    ));

    // Assert error message.

    $this->assertText(t('"@import_period" and "@import_on_create" are both turned off and the importer is not attached to a content type. Unless you have alternative methods of running imports for this importer, Feeds will not import anything for this importer.', array(

      '@import_period' => t('Periodic import'),

      '@import_on_create' => t('Import on submission'),

    )));

  }

  /**

   * Tests if the user is warned when having "Import on submission" turned off,

   * "Process in background" turned on and using the standalone form.

   */

  public function testWarningImportOnSubmissionTurnedOffAndProcessInBackgroundTurnedOn() {

    // Create an importer.

    $this->createImporterConfiguration('Test feed', 'test_feed');

    $this->setSettings('test_feed', NULL, array(

      'content_type' => '',

      'import_on_create' => FALSE,

      'process_in_background' => TRUE,

    ));

    // Assert error message.

    $this->assertText(t('Since "@import_on_create" is turned off and the importer is not attached to a content type, the "@process_in_background" setting may have no effect. When submitting the standalone form with the "@import_on_create" setting turned off, the feed is only scheduled for periodic import.', array(

      '@import_on_create' => t('Import on submission'),

      '@process_in_background' => t('Process in background'),

    )));

  }

  /**

   * Tests if the user is warned when the importer is attached to the same

   * content type as the one selected on the node processor.

   */

  public function testWarningWhenAttachImporterToContentTypeAlsoOnTheNodeProcessor() {

    // Create content type.

    $type = $this->drupalCreateContentType();

    $typename = $type->type;

    // Create an importer.

    $this->createImporterConfiguration('Test feed', 'test_feed');

    // Attach to content type.

    $this->setSettings('test_feed', NULL, array(

      'content_type' => $typename,

    ));

    // Select the same content type on the node processor.

    $this->setSettings('test_feed', 'FeedsNodeProcessor', array(

      'bundle' => $typename,

    ));

    $this->assertText('The importer is attached to the same content type as the content type selected on the node processor. Unless you have a very advanced use case, these two should never be the same.');

  }

  /**

   * Tests if the user is warned when importing an importer with invalid configuration.

   */

  public function testInvalidConfigurationWhenImportingImporter() {

    $name = $this->randomString();

    $id = drupal_strtolower($this->randomName());

    $this->createImporterConfiguration($name, $id);

    $this->setPlugin($id, 'FeedsCSVParser');

    $this->setPlugin($id, 'FeedsFileFetcher');

    $this->drupalGet('admin/structure/feeds/' . $id . '/export');

    $export = $this->xpath('//textarea[1]/text()');

    $export = (string) $export[0];

    // Add in some invalid configuration in the export.

    $invalid_plugin = $this->randomName();

    $invalid_bundle = strtolower($this->randomName());

    $invalid_language = 'de';

    $export = str_replace('FeedsFileFetcher', $invalid_plugin, $export);

    $export = str_replace("'bundle' => 'article'", "'bundle' => '" . $invalid_bundle . "'", $export);

    $export = str_replace("'language' => 'und'", "'language' => '" . $invalid_language . "'", $export);

    // Delete this importer.

    $this->drupalPost('admin/structure/feeds/' . $id . '/delete', array(), t('Delete'));

    // Try to import.

    $edit = array(

      'importer' => $export,

    );

    $this->drupalPost('admin/structure/feeds/import', $edit, t('Import'));

    // Assert that the importer was not imported.

    $this->assertNoText("Successfully imported the $id feeds importer.");

    $this->assertFalse(feeds_importer_load($id), 'The importer was not created.');

    // Assert error messages.

    $this->assertText(format_string('The plugin @invalid_plugin is unavailable.', array(

      '@invalid_plugin' => $invalid_plugin,

    )));

    $this->assertText(format_string('Invalid value @invalid_bundle for config option Bundle.', array(

      '@invalid_bundle' => $invalid_bundle,

    )));

    $this->assertText(format_string('Invalid value @invalid_lang for config option Language.', array(

      '@invalid_lang' => $invalid_language,

    )));

    // Try if the importer is imported when ignoring validation.

    $edit['bypass_validation'] = 1;

    $this->drupalPost(NULL, $edit, t('Import'));

    // Assert that the importer has been imported now.

    drupal_static_reset();

    $this->assertTrue(feeds_importer_load($id) instanceof FeedsImporter, 'The importer was created.');

    // But the warnings should still be displayed.

    $this->drupalGet('admin/structure/feeds/' . $id);

    $this->assertText(format_string('The plugin @invalid_plugin is unavailable.', array(

      '@invalid_plugin' => $invalid_plugin,

    )));

    $this->assertText(format_string('Invalid value @invalid_bundle for config option Bundle.', array(

      '@invalid_bundle' => $invalid_bundle,

    )));

    $this->assertText(format_string('Invalid value @invalid_lang for config option Language.', array(

      '@invalid_lang' => $invalid_language,

    )));

  }

  /**

   * Edits an importer configuration.

   *

   * @param string $name

   *   The natural name of the feed.

   * @param string $id

   *   The persistent id of the feed.

   */

  protected function doEditFeedsConfiguration($name = 'Syndication', $id = 'syndication') {

    // Assert UI elements.

    $this->drupalGet('admin/structure/feeds/'. $id);

    $this->assertText($name);

    $this->assertText('Basic settings');

    $this->assertText('Fetcher');

    $this->assertText('HTTP Fetcher');

    $this->assertText('Parser');

    $this->assertText('Common syndication parser');

    $this->assertText('Processor');

    $this->assertText('Node processor');

    $this->assertText('Getting started');

    $this->assertRaw('admin/structure/feeds/'. $id .'/settings');

    $this->assertRaw('admin/structure/feeds/'. $id .'/settings/FeedsNodeProcessor');

    $this->assertRaw('admin/structure/feeds/'. $id .'/fetcher');

    $this->assertRaw('admin/structure/feeds/'. $id .'/parser');

    $this->assertRaw('admin/structure/feeds/'. $id .'/processor');

  }

  /**

   * Determine whether this object is persistent.

   *

   * @return bool

   *   True if the object is persistent.

   *   False otherwise.

   */

  public function doesExist() {

    return ($this->export_type == FEEDS_EXPORT_NONE) ? FALSE : TRUE;

  }

  /**

   * Determine whether this object is enabled.

   *

   * @return bool

   *   True if the object is enabled.

   *   False otherwise.

   */

  public function isEnabled() {

    return $this->disabled ? FALSE : TRUE;

  }

    if (!$this->doesExist()) {

    if (!$this->isEnabled()) {

   * @return array

    return array() + module_invoke_all('feeds_config_defaults', $this);

  }

  /**

   * Validates the configuration.

   *

   * @return array

   *   A list of errors.

   */

  public function validateConfig() {

<?php

/**

 * Cache implementation for the Feeds HTTP cache.

 */

class FeedsHTTPCache extends DrupalDatabaseCache {

  /**

   * Returns cache object.

   *

   * @param string $bin

   *   The cache bin.

   *

   * @return FeedsHTTPCache

   *   An instance of FeedsHTTPCache.

   */

  public static function getInstance($bin) {

    $cache_object = _cache_get_object($bin);

    if (!($cache_object instanceof self)) {

      // A different cache class could be used for the cache_feeds_http bin that

      // does not extend FeedsHTTPCache. In this case, just instantiate the

      // FeedsHTTPCache class.

      $cache_object = new self($bin);

    }

    return $cache_object;

  }

  /**

   * Returns cache dir.

   *

   * @return string

   *   The cache dir to use.

   */

  public function getCacheDir() {

    $dir = variable_get('feeds_http_file_cache_dir', NULL);

    if ($dir) {

      return $dir;

    }

    else {

      $schemes = file_get_stream_wrappers(STREAM_WRAPPERS_WRITE_VISIBLE);

      $scheme = isset($schemes['private']) ? 'private' : 'public';

      return $scheme . '://feeds/cache';

    }

  }

  /**

   * Returns a list of file names in the cache directory.

   *

   * @return array

   *   A list of files.

   */

  public function getFileList() {

    $files = array();

    $file_cache_dir = $this->getCacheDir();

    if (is_dir($file_cache_dir)) {

      $dir = dir($file_cache_dir);

      while (($entry = $dir->read()) !== FALSE) {

        if ($entry == '.' || $entry == '..') {

          continue;

        }

        $files[] = $entry;

      }

      $dir->close();

    }

    return $files;

  }