feeds.module

<?php

/**
 * @file
 * Feeds - basic API functions and hook implementations.
 */

/**
 * Common request time, use as point of reference and to avoid calls to time().
 *
 * @var int
 */
define('FEEDS_REQUEST_TIME', time());

/**
 * Do not schedule a feed for refresh.
 *
 * @var int
 */
define('FEEDS_SCHEDULE_NEVER', -1);

/**
 * Never expire feed items.
 *
 * @var int
 */
define('FEEDS_EXPIRE_NEVER', -1);

/**
 * Status of batched operations: complete.
 *
 * @var float
 */
define('FEEDS_BATCH_COMPLETE', 1.0);

/**
 * Status of batched operations: active
 *
 * @var float
 */
define('FEEDS_BATCH_ACTIVE', 0.0);

/**
 * Implements hook_boot().
 */
function feeds_boot() {
  // Set the default class implementation for the Feeds HTTP Cache if it's
  // not set in settings.php. Need to assign it to the global $settings here so
  // it gets picked up whenever a cache function is called for this bin.
  if (empty(settings_get('cache_class_cache_feeds_http'))) {
    global $settings;
    $settings['cache_class_cache_feeds_http'] = 'FeedsHTTPCache';
  }
}

/**
 * @defgroup hooks Hook and callback implementations
 * @{
 */

function feeds_config_info() {
  $prefixes['feeds.feeds_importer'] = array(
    'name_key' => 'id',
    'label_key' => 'id',
    'group' => t('Feeds importers'),
  );

  $prefixes['feeds.settings'] = array(
    'label' => t('Feeds settings'),
    'group' => t('Configuration'),
  );
  return $prefixes;
}

/**
 * Implements hook_hook_info().
 */
function feeds_hook_info() {
  $hooks = array(
    'feeds_plugins',
    'feeds_after_parse',
    'feeds_before_import',
    'feeds_before_update',
    'feeds_prevalidate',
    'feeds_presave',
    'feeds_after_save',
    'feeds_after_import',
    'feeds_after_clear',
    'feeds_processor_targets',
    'feeds_processor_targets_alter',
    'feeds_parser_sources_alter',
    'feeds_config_defaults',
    'feeds_fetcher_config_defaults',
    'feeds_parser_config_defaults',
    'feeds_processor_config_defaults',
  );

  return array_fill_keys($hooks, array('group' => 'feeds'));
}

/**
 * Implements hook_cron().
 */
function feeds_cron() {
  // Expire old log entries.
  db_delete('feeds_log')
    ->condition('request_time', REQUEST_TIME - 604800, '<')
    ->execute();

  // Find importers that need to be rescheduled.
  $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 = state_get('feeds_sync_cache_feeds_http_last_check');
  $interval = config_get('feeds.settings', 'feeds_sync_cache_feeds_http_interval');
  if ($last_check < (REQUEST_TIME - $interval)) {
    // Check first if the task isn't already queued.
    $queue = BackdropQueue::get('feeds_sync_cache_feeds_http');
    if ($queue->numberOfItems() < 1) {
      // Queue sync task.
      FeedsHTTPCache::getInstance('cache_feeds_http')->startSync();
    }
    state_set('feeds_sync_cache_feeds_http_last_check', REQUEST_TIME);
  }
}

/**
 * Implements hook_cron_job_scheduler_info().
 *
 * Compare queue names with key names in feeds_cron_queue_info().
 */
function feeds_cron_job_scheduler_info() {
  $info = array();
  $info['feeds_source_import'] = array(
    'queue name' => 'feeds_source_import',
  );
  // feeds_source_clear never gets called, since we now use the queue directly.
  // This is left in case any background jobs are still running after an
  // upgrade.
  $info['feeds_source_clear'] = array(
    'queue name' => 'feeds_source_clear',
  );
  $info['feeds_source_expire'] = array(
    'queue name' => 'feeds_source_expire',
  );
  $info['feeds_push_unsubscribe'] = array(
    'queue name' => 'feeds_push_unsubscribe',
  );
  return $info;
}

/**
 * Implements hook_cron_queue_info().
 */
function feeds_cron_queue_info() {
  $queues = array();
  $queues['feeds_source_import'] = array(
    'worker callback' => 'feeds_source_import',
    'time' => 60,
  );
  $queues['feeds_source_clear'] = array(
    'worker callback' => 'feeds_source_clear',
  );
  $queues['feeds_source_expire'] = array(
    'worker callback' => 'feeds_source_expire',
  );
  $queues['feeds_push_unsubscribe'] = array(
    'worker callback' => 'feeds_push_unsubscribe',
  );
  $queues['feeds_sync_cache_feeds_http'] = array(
    'worker callback' => 'feeds_sync_cache_feeds_http',
  );

  return $queues;
}

/**
 * Scheduler callback for importing from a source.
 *
 * @param array $job
 *   A job definition, which consists of at least the following elements:
 *   - type (string)
 *     The importer ID.
 *   - id (int)
 *     The Feed node ID if the importer is attached to a content type. Otherwise
 *     0.
 */
function feeds_source_import(array $job) {
  $source = _feeds_queue_worker_helper($job, 'import');
  if ($source->doesExist()) {
    $source->scheduleImport();
  }
}

/**
 * Scheduler callback for deleting all items from a source.
 *
 * @param array $job
 *   A job definition, which consists of at least the following elements:
 *   - type (string)
 *     The importer ID.
 *   - id (int)
 *     The Feed node ID if the importer is attached to a content type. Otherwise
 *     0.
 */
function feeds_source_clear(array $job) {
  $source = _feeds_queue_worker_helper($job, 'clear');
  if ($source->doesExist()) {
    $source->scheduleClear();
  }
}

/**
 * Scheduler callback for expiring content.
 *
 * @param array $job
 *   A job definition, which consists of at least the following elements:
 *   - type (string)
 *     The importer ID.
 *   - id (int)
 *     The Feed node ID if the importer is attached to a content type. Otherwise
 *     0.
 */
function feeds_source_expire(array $job) {
  $source = _feeds_queue_worker_helper($job, 'expire');
  if ($source->doesExist()) {
    $source->scheduleExpire();
  }
}

/**
 * Executes a method on a feed source.
 *
 * @param array $job
 *   A job definition, which consists of at least the following elements:
 *   - type (string)
 *     The importer ID.
 *   - id (int)
 *     The Feed node ID if the importer is attached to a content type. Otherwise
 *     0.
 * @param string $method
 *   The method to execute.
 */
function _feeds_queue_worker_helper(array $job, $method) {
  $source = feeds_source($job['type'], $job['id']);
  try {
    $source->existing()->$method();
  }
  catch (FeedsNotExistingException $e) {
    // Eventually remove the job from job scheduler.
    JobScheduler::get('feeds_source_import')->remove($job);
  }
  catch (Exception $e) {
    $source->log($method, $e->getMessage(), array(), WATCHDOG_ERROR);
  }

  return $source;
}

/**
 * Scheduler callback for keeping the cache dir and cache entries in sync.
 *
 * This makes sure that files that appear in the Feeds cache directory that are
 * no longer referenced in the cache_feeds_http bin, are cleaned up.
 * The entries saved in the cache_feeds_http bin and the actual cached files
 * saved on the file system can get out of sync when:
 * - Truncating the cache_feeds_http table manually.
 * - When using an alternative cache class for the cache_feeds_http bin
 *   (other than 'FeedsHTTPCache').
 */
function feeds_sync_cache_feeds_http(array $job) {
  FeedsHTTPCache::getInstance('cache_feeds_http')->sync($job['files']);
}

/**
 * Scheduler callback for unsubscribing from PuSH hubs.
 *
 * @param array $job
 *   A job definition, which consists of at least the following elements:
 *   - type (string)
 *     The importer ID.
 *   - id (int)
 *     The Feed node ID if the importer is attached to a content type. Otherwise
 *     0.
 */
function feeds_push_unsubscribe($job) {
  $source = feeds_source($job['type'], $job['id']);
  /** @var FeedsFetcher $fetcher */
  $fetcher = feeds_plugin('FeedsHTTPFetcher', $source->importer->id);
  $fetcher->unsubscribe($source);
}

/**
 * Batch API worker callback. Used by FeedsSource::startBatchAPIJob().
 *
 * @todo Harmonize Job Scheduler API callbacks with Batch API callbacks?
 *
 * @param string $method
 *   Method to execute on importer; one of 'import' or 'clear'.
 * @param string $importer_id
 *   Identifier of a FeedsImporter object.
 * @param int $feed_nid
 *   If importer is attached to content type, feed node id identifying the
 *   source to be imported. Set to zero if not attached to a node.
 * @param array $context
 *   Batch context.
 *
 * @see FeedsSource::startBatchAPIJob()
 */
function feeds_batch($method, $importer_id, $feed_nid, &$context) {
  if (!isset($feed_nid)) {
    $feed_nid = 0;
  }
  $context['finished'] = FEEDS_BATCH_COMPLETE;
  try {
    $context['finished'] = feeds_source($importer_id, $feed_nid)->$method();
  }
  catch (Exception $e) {
    backdrop_set_message($e->getMessage(), 'error');
  }
}

/**
 * Reschedule one or all importers.
 *
 * @param string|bool|null $importer_id
 *   If TRUE, all importers will be rescheduled, if FALSE, no importers will
 *   be rescheduled, if an importer id, only importer of that id will be
 *   rescheduled.
 *
 * @return string[]
 *   A list of importer ids that need rescheduling.
 */
function feeds_reschedule($importer_id = NULL) {
  $reschedule = state_get('feeds_reschedule');

  if ($importer_id === TRUE || $importer_id === FALSE) {
    $reschedule = $importer_id;
  }
  elseif (is_string($importer_id) && $reschedule !== TRUE) {
    $reschedule = array_filter((array) $reschedule);
    $reschedule[$importer_id] = $importer_id;
  }

  if (isset($importer_id)) {
    state_set('feeds_reschedule', $reschedule);
  }

  if ($reschedule === TRUE) {
    return feeds_enabled_importers();
  }
  elseif ($reschedule === FALSE) {
    return array();
  }

  return $reschedule;
}

/**
 * Implements hook_permission().
 */
function feeds_permission() {
  $perms = array(
    'administer feeds' => array(
      'title' => t('Administer Feeds'),
      'description' => t('Create, update, delete importers, execute import and delete tasks on any importer.'),
    ),
  );
  foreach (feeds_importer_load_all() as $importer) {
    $perms["import $importer->id feeds"] = array(
      'title' => t('Import @name feeds', array('@name' => $importer->config['name'])),
    );
    $perms["clear $importer->id feeds"] = array(
      'title' => t('Delete items from @name feeds', array('@name' => $importer->config['name'])),
    );
    $perms["unlock $importer->id feeds"] = array(
      'title' => t('Unlock imports from @name feeds', array('@name' => $importer->config['name'])),
      'description' => t('If a feed importation breaks for some reason, users with this permission can unlock them.'),
    );
  }
  return $perms;
}

/**
 * Implements hook_forms().
 *
 * Declare form callbacks for all known classes derived from FeedsConfigurable.
 */
function feeds_forms($form_id, $args) {
  // Check if the requested form is a Feeds form.
  if (!stripos($form_id, '_feeds_form')) {
    return;
  }

  $forms = array();
  $forms['FeedsImporter_feeds_form']['callback'] = 'feeds_form';
  $plugins = FeedsPlugin::all();
  foreach ($plugins as $plugin) {
    $forms[$plugin['handler']['class'] . '_feeds_form']['callback'] = 'feeds_form';
  }
  return $forms;
}

/**
 * Implements hook_menu().
 */
function feeds_menu() {
  $items = array();
  $items['import'] = array(
    'title' => 'Feeds Import',
    'page callback' => 'feeds_page',
    'access callback' => 'feeds_page_access',
    'file' => 'feeds.pages.inc',
  );
  $items['admin/content/import'] = array(
    'title' => 'Feeds Import',
    'page callback' => 'feeds_page',
    'access callback' => 'feeds_page_access',
    'file' => 'feeds.pages.inc',
    'menu_name' => 'management',
  );
  $items['import/%feeds_importer'] = array(
    'title callback' => 'feeds_importer_title',
    'title arguments' => array(1),
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('feeds_import_form', 1),
    'access callback' => 'feeds_access',
    'access arguments' => array('import', 1),
    'file' => 'feeds.pages.inc',
  );
  $items['import/%feeds_importer/import'] = array(
    'title' => 'Import',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
  );
  $items['import/%feeds_importer/delete-items'] = array(
    'title' => 'Delete items',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('feeds_delete_tab_form', 1),
    'access callback' => 'feeds_access',
    'access arguments' => array('clear', 1),
    'file' => 'feeds.pages.inc',
    'type' => MENU_LOCAL_TASK,
  );
  $items['import/%feeds_importer/unlock'] = array(
    'title' => 'Unlock',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('feeds_unlock_tab_form', 1),
    'access callback' => 'feeds_access',
    'access arguments' => array('unlock', 1),
    'file' => 'feeds.pages.inc',
    'type' => MENU_LOCAL_TASK,
  );
  $items['import/%feeds_importer/template'] = array(
    'page callback' => 'feeds_importer_template',
    'page arguments' => array(1),
    'access callback' => 'feeds_access',
    'access arguments' => array('import', 1),
    'file' => 'feeds.pages.inc',
    'type' => MENU_CALLBACK,
  );
  $items['node/%node/import'] = array(
    'title' => 'Import',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('feeds_import_tab_form', 1),
    'access callback' => 'feeds_access',
    'access arguments' => array('import', 1),
    'file' => 'feeds.pages.inc',
    'type' => MENU_LOCAL_TASK,
    'weight' => 10,
  );
  $items['node/%node/delete-items'] = array(
    'title' => 'Delete items',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('feeds_delete_tab_form', NULL, 1),
    'access callback' => 'feeds_access',
    'access arguments' => array('clear', 1),
    'file' => 'feeds.pages.inc',
    'type' => MENU_LOCAL_TASK,
    'weight' => 11,
  );
  $items['node/%node/unlock'] = array(
    'title' => 'Unlock',
    'page callback' => 'backdrop_get_form',
    'page arguments' => array('feeds_unlock_tab_form', NULL, 1),
    'access callback' => 'feeds_access',
    'access arguments' => array('unlock', 1),
    'file' => 'feeds.pages.inc',
    'type' => MENU_LOCAL_TASK,
    'weight' => 11,
  );
  // @todo Eliminate this step and thus eliminate clearing menu cache when
  // manipulating importers.
  foreach (feeds_importer_load_all() as $importer) {
    $items += $importer->fetcher->menuItem();
  }
  return $items;
}

/**
 * Implements hook_admin_paths().
 */
function feeds_admin_paths() {
  $paths = array(
    'import' => TRUE,
    'import/*' => TRUE,
    'node/*/import' => TRUE,
    'node/*/delete-items' => TRUE,
    'node/*/log' => TRUE,
  );
  return $paths;
}

/**
 * Menu loader callback.
 *
 * @param string $id
 *   The ID of the importer to load.
 *
 * @return FeedsImporter|false
 *   A FeedsImporter instance if found. False otherwise.
 */
function feeds_importer_load($id) {
  try {
    $importer = feeds_importer($id);
    if ($importer->doesExist()) {
      return $importer;
    }
  }
  catch (InvalidArgumentException $e) {
  }

  return FALSE;
}

/**
 * Title callback.
 *
 * @param FeedsImporter $importer
 *   The importer to return the page title for.
 *
 * @return string
 *   A page title.
 */
function feeds_importer_title(FeedsImporter $importer) {
  return $importer->config['name'];
}

/**
 * Implements hook_theme().
 */
function feeds_theme() {
  return array(
    'feeds_upload' => array(
      'file' => 'feeds.pages.inc',
      'render element' => 'element',
    ),
    'feeds_source_status' => array(
      'file' => 'feeds.pages.inc',
      'variables' => array(
        'progress_importing' => NULL,
        'progress_clearing' => NULL,
        'imported' => NULL,
        'count' => NULL,
      ),
    ),
  );
}

/**
 * Menu access callback.
 *
 * @param string $action
 *   The action to be performed. Possible values are:
 *   - import;
 *   - clear;
 *   - unlock.
 * @param object|string $param
 *   Node object or FeedsImporter id.
 *
 * @return bool
 *   True if access is granted. False otherwise.
 */
function feeds_access($action, $param) {
  if (!in_array($action, array('import', 'clear', 'unlock'))) {
    // If $action is not one of the supported actions, we return access denied.
    return FALSE;
  }

  $importer_id = FALSE;
  if (is_string($param)) {
    $importer_id = $param;
  }
  elseif ($param instanceof FeedsImporter) {
    $importer_id = $param->id;
  }
  elseif ($param->type) {
    $importer_id = feeds_get_importer_id($param->type);
  }

  // Check for permissions if feed id is present, otherwise return FALSE.
  if ($importer_id) {
    if (user_access('administer feeds') || user_access("{$action} {$importer_id} feeds")) {
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Access callback to determine if the user can import Feeds importers.
 *
 * Feeds imports require an additional access check because they are
 * configuration.
 *
 * @return bool
 *   True if access is granted. False otherwise.
 */
function feeds_importer_import_access() {
  return user_access('administer feeds') && user_access('synchronize configuration');
}

/**
 * Menu access callback.
 *
 * @return bool
 *   True if access is granted. False otherwise.
 */
function feeds_page_access() {
  if (user_access('administer feeds')) {
    return TRUE;
  }
  foreach (feeds_enabled_importers() as $id) {
    if (user_access("import $id feeds")) {
      return TRUE;
    }
  }
  return FALSE;
}

/**
 * Implements hook_exit().
 */
function feeds_exit() {
  // Process any pending PuSH subscriptions.
  $jobs = feeds_get_subscription_jobs();
  foreach ($jobs as $job) {
    if (!isset($job['fetcher']) || !isset($job['source'])) {
      continue;
    }
    $job['fetcher']->subscribe($job['source']);
  }

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

/**
 * Implements hook_views_api().
 */
function feeds_views_api() {
  return array(
    'api' => 3,
    'path' => backdrop_get_path('module', 'feeds') . '/views',
  );
}

/**
 * Implements hook_feeds_plugins().
 */
function feeds_feeds_plugins() {
  module_load_include('inc', 'feeds', 'feeds.plugins');
  return _feeds_feeds_plugins();
}

/**
 * Gets the feed_nid for a single entity.
 *
 * @param int $entity_id
 *   The entity id.
 * @param string $entity_type
 *   The type of entity.
 *
 * @return int|bool
 *   The feed_nid of the entity, or FALSE if the entity doesn't belong to a
 *   feed.
 */
function feeds_get_feed_nid($entity_id, $entity_type) {
  return db_query("SELECT feed_nid FROM {feeds_item} WHERE entity_type = :type AND entity_id = :id", array(':type' => $entity_type, ':id' => $entity_id))->fetchField();
}

/**
 * Implements hook_entity_insert().
 */
function feeds_entity_insert($entity, $type) {
  list($id) = entity_extract_ids($type, $entity);
  feeds_item_info_insert($entity, $id);
}

/**
 * Implements hook_entity_update().
 */
function feeds_entity_update($entity, $type) {
  list($id) = entity_extract_ids($type, $entity);
  feeds_item_info_save($entity, $id);
}

/**
 * Implements hook_entity_delete().
 */
function feeds_entity_delete($entity, $type) {
  list($id) = entity_extract_ids($type, $entity);

  // Delete any imported items produced by the source.
  db_delete('feeds_item')
    ->condition('entity_type', $type)
    ->condition('entity_id', $id)
    ->execute();
}

/**
 * Implements hook_node_validate().
 */
function feeds_node_validate($node, $form, &$form_state) {
  if (!$importer_id = feeds_get_importer_id($node->type)) {
    return;
  }
  // Keep a copy of the title for subsequent node creation stages.
  // @todo: revisit whether $node still looses all of its properties
  // between validate and insert stage.
  $last_title = &backdrop_static('feeds_node_last_title');
  $last_feeds = &backdrop_static('feeds_node_last_feeds');

  // On validation stage we are working with a FeedsSource object that is
  // not tied to a nid - when creating a new node there is no
  // $node->nid at this stage.
  $source = feeds_source($importer_id);

  // Node module magically moved $form['feeds'] to $node->feeds :P.
  // configFormValidate may modify $last_feed, smuggle it to update/insert stage
  // through a static variable.
  $last_feeds = $node->feeds;
  $source->configFormValidate($last_feeds);

  // Check if title form element is hidden.
  $title_hidden = (isset($form['title']['#access']) && !$form['title']['#access']);

  // If the node title is empty and the title form element wasn't hidden, try to
  // retrieve the title from the feed.
  if (isset($node->title) && trim($node->title) == '' && !$title_hidden) {
    try {
      $source->addConfig($last_feeds);
      if (!$last_title = $source->preview()->title) {
        throw new Exception();
      }
    }
    catch (Exception $e) {
      backdrop_set_message($e->getMessage(), 'error');
      form_set_error('title', t('Could not retrieve title from feed.'));
    }
  }
}

/**
 * Implements hook_node_presave().
 */
function feeds_node_presave($node) {
  // Populate $node->title and $node->feed from result of validation phase.
  $last_title = &backdrop_static('feeds_node_last_title');
  $last_feeds = &backdrop_static('feeds_node_last_feeds');
  if (empty($node->title) && !empty($last_title)) {
    $node->title = $last_title;
  }
  if (!empty($last_feeds)) {
    $node->feeds = $last_feeds;
  }
  $last_title = NULL;
  $last_feeds = NULL;

  // Update "changed" value if there was mapped to that.
  if (isset($node->feeds_item->node_changed)) {
    $node->changed = $node->feeds_item->node_changed;
  }
}

/**
 * Implements hook_node_insert().
 */
function feeds_node_insert($node) {
  // Source attached to node.
  if (isset($node->feeds) && $importer_id = feeds_get_importer_id($node->type)) {
    $source = feeds_source($importer_id, $node->nid);
    $source->addConfig($node->feeds);
    $source->save();

    // Start import if requested.
    if (feeds_importer($importer_id)->config['import_on_create'] && !isset($node->feeds['suppress_import'])) {
      $source->startImport();
    }
    // Schedule the source.
    $source->schedule();
  }
}

/**
 * Implements hook_node_update().
 */
function feeds_node_update($node) {
  // Source attached to node.
  if (isset($node->feeds) && $importer_id = feeds_get_importer_id($node->type)) {
    $source = feeds_source($importer_id, $node->nid);
    $source->addConfig($node->feeds);
    $source->save();
    $source->ensureSchedule();
  }
}

/**
 * Implements hook_node_delete().
 */
function feeds_node_delete($node) {
  // Source attached to node.
  // Make sure we don't leave any orphans behind: Do not use
  // feeds_get_importer_id() to determine importer id as the importer may have
  // been deleted.
  if ($importer_id = db_query("SELECT id FROM {feeds_source} WHERE feed_nid = :nid", array(':nid' => $node->nid))->fetchField()) {
    feeds_source($importer_id, $node->nid)->delete();
  }
}

/**
 * Implements hook_form_BASE_FORM_ID_alter().
 */
function feeds_form_node_form_alter(&$form, $form_state) {
  if ($importer_id = feeds_get_importer_id($form['#node']->type)) {
    // Enable uploads.
    $form['#attributes']['enctype'] = 'multipart/form-data';

    // Build form.
    $source = feeds_source($importer_id, empty($form['#node']->nid) ? NULL : $form['#node']->nid);
    $form['feeds'] = array(
      '#type' => 'fieldset',
      '#title' => t('Feed'),
      '#tree' => TRUE,
      '#weight' => 0,
    );
    $form['feeds'] += $source->configForm($form_state);
    $form['#feed_id'] = $importer_id;

    // If the parser has support for delivering a source title, set node title
    // to not required and try to retrieve it from the source if the node title
    // is left empty by the user.
    // @see feeds_node_validate()
    if (isset($form['title']) && $source->importer()->parser->providesSourceTitle()) {
      $form['title']['#required'] = FALSE;
    }
  }
}

/**
 * Implements hook_field_extra_fields().
 */
function feeds_field_extra_fields() {
  $extras = array();
  foreach (node_type_get_names() as $type => $name) {
    if (feeds_get_importer_id($type)) {
      $extras['node'][$type]['form']['feeds'] = array(
        'label' => t('Feed'),
        'description' => t('Feeds module form elements'),
        'weight' => 0,
      );
    }
  }
  return $extras;
}

/**
 * Implements hook_features_pipe_COMPONENT_alter() for 'feeds_importer'.
 *
 * Automatically adds dependencies when a Feed importer is selected in Features.
 */
function feeds_features_pipe_feeds_importer_alter(&$pipe, $data, &$export) {
  foreach ($data as $importer_id) {
    if ($importer = feeds_importer_load($importer_id)) {
      $export['dependencies'] = array_merge($export['dependencies'], $importer->dependencies());
    }
  }
}

/**
 * Implements hook_system_info_alter().
 *
 * Goes through a list of all modules that provide Feeds plugins and makes them
 * required if there are any importers using those plugins.
 */
function feeds_system_info_alter(array &$info, $file, $type) {
  if ($type !== 'module' || !module_exists($file->name) || !module_hook($file->name, 'feeds_plugins')) {
    return;
  }

  // Don't make Feeds require itself, otherwise you can't disable Feeds until
  // all importers are deleted.
  if ($file->name === 'feeds') {
    return;
  }

  // Get the plugins that belong to the current module.
  $module_plugins = array();
  foreach (feeds_get_plugins() as $plugin_id => $plugin) {
    if ($file->name === $plugin['module']) {
      $module_plugins[$plugin_id] = TRUE;
    }
  }

  // Check if any importers are using any plugins from the current module.
  foreach (feeds_importer_load_all(TRUE) as $importer) {

    $configuration = $importer->getConfig();

    foreach (array('fetcher', 'parser', 'processor') as $plugin_type) {
      $plugin_key = $configuration[$plugin_type]['plugin_key'];
      if (isset($module_plugins[$plugin_key])) {
        $info['disabled'] = TRUE;
        break 2;
      }
    }
  }

  if (empty($info['disabled'])) {
    return;
  }

  if (module_exists('feeds_ui') && user_access('administer feeds')) {
    $info['explanation'] = t('Feeds is currently using this module for one or more <a href="@link">importers</a>', array('@link' => url('admin/structure/feeds')));
  }
  else {
    $info['explanation'] = t('Feeds is currently using this module for one or more importers');
  }
}

/**
 * Implements hook_module_implements_alter().
 */
function feeds_module_implements_alter(array &$implementations, $hook) {
  if ($hook === 'feeds_processor_targets_alter') {
    // We need two implementations of this hook, so we add one that gets
    // called first, and move the normal one to last.
    $implementations = array('_feeds' => FALSE) + $implementations;

    // Move normal implementation to last.
    $group = $implementations['feeds'];
    unset($implementations['feeds']);
    $implementations['feeds'] = $group;
  }
}

/**
 * Implements hook_feeds_processor_targets_alter().
 *
 * @see feeds_feeds_processor_targets()
 * @see feeds_feeds_processor_targets_alter()
 */
function _feeds_feeds_processor_targets_alter(array &$targets, $entity_type, $bundle) {
  // If hook_feeds_processor_targets() hasn't been called, for instance, by
  // older processors, invoke it ourself.
  if (!backdrop_static('feeds_feeds_processor_targets', FALSE)) {
    $targets += module_invoke_all('feeds_processor_targets', $entity_type, $bundle);
  }
}

/**
 * Implements hook_flush_caches().
 */
function feeds_flush_caches() {
  // The update to add the table needs to have run. Taken from
  // https://www.drupal.org/node/2511858
  include_once BACKDROP_ROOT . '/core/includes/install.inc';

  if (backdrop_get_installed_schema_version('feeds') >= 7212) {
    return array('cache_feeds_http');
  }
  return array();
}

/**
 * Implements hook_admin_bar_output_build().
 *
 * Shows available importers in the "Content" section of the admin menu.
 * Requires the "admin_bar" module to be enabled.
 */
function feeds_admin_bar_output_build(array &$content) {
  $access = FALSE;
  foreach (feeds_enabled_importers() as $importer_id) {
    if (user_access('administer feeds') || user_access("import $importer_id feeds")) {
      $access = TRUE;
      break;
    }
  }

  if (!$access) {
    return;
  }

  foreach (feeds_importer_load_all() as $importer) {
    $content['menu']['menu']['admin/content']['admin/content/import'][$importer->id] = array(
      '#title' => check_plain($importer->config['name']),
      '#href' => !empty($importer->config['content_type']) ? 'node/add/' . str_replace('_', '-', $importer->config['content_type']) : 'import/' . check_plain($importer->id),
      '#access' => user_access('administer feeds') || user_access("import $importer->id feeds"),
    );
  }
}

/**
 * Implements hook_menu_local_tasks_alter().
 *
 * Adds "Import" link as local action on content overview page.
 */
function feeds_menu_local_tasks_alter(&$data, $router_item, $root_path) {
  if ($root_path == 'admin/content') {
    $data['actions']['output'][] = array(
      '#theme' => 'menu_local_action',
      '#link' => array(
        'title' => t('Import'),
        'href' => 'import',
        'localized_options' => array(
          'attributes' => array(
            'title' => t('Import'),
          ),
        ),
      ),
      '#access' => feeds_page_access(),
      // Add weight so it appears after the local action "Add content".
      '#weight' => 1,
    );
  }
}

/**
 * @}
 */

/**
 * @defgroup utility Utility functions
 * @{
 */

/**
 * Loads all importers.
 *
 * @param bool $load_disabled
 *   Pass TRUE to load all importers, enabled or disabled, pass FALSE to only
 *   retrieve enabled importers.
 *
 * @return array
 *   An array of all feed configurations available.
 */
function feeds_importer_load_all($load_disabled = FALSE) {
  $feeds = array();
  $configs = feeds_load_importer_object();
  if ($configs) {
    foreach ($configs as $config) {
      if (!empty($config->id) && ($load_disabled || empty($config->disabled))) {
        $feeds[$config->id] = feeds_importer($config->id);
      }
    }
    uasort($feeds, 'feeds_importer_name_sort');
  }

  return $feeds;
}

/**
 * Sorts importers by name.
 *
 * Callback for uasort().
 *
 * @param FeedsImporter $a
 *   The first FeedsImporter for comparison.
 * @param FeedsImporter $b
 *   The second FeedsImporter for comparison.
 *
 * @return int
 *   The comparison result for uasort().
 */
function feeds_importer_name_sort(FeedsImporter $a, FeedsImporter $b) {
  return strcasecmp($a->config['name'], $b->config['name']);
}

/**
 * Gets an array of enabled importer ids.
 *
 * @return string[]
 *   An array where the values contain ids of enabled importers.
 */
function feeds_enabled_importers() {
  return array_keys(_feeds_importer_digest());
}

/**
 * Gets an enabled importer configuration by content type.
 *
 * @param string $content_type
 *   A node type string.
 *
 * @return string|false
 *   A FeedsImporter id if there is an importer for the given content type,
 *   FALSE otherwise.
 */
function feeds_get_importer_id($content_type) {
  $importers = array_flip(_feeds_importer_digest());
  return isset($importers[$content_type]) ? $importers[$content_type] : FALSE;
}

/**
 * Helper function for feeds_get_importer_id() and feeds_enabled_importers().
 */
function _feeds_importer_digest() {
  $importers = &backdrop_static(__FUNCTION__);
  if ($importers === NULL) {
    if ($cache = cache_get(__FUNCTION__)) {
      $importers = $cache->data;
    }
    else {
      $importers = array();
      foreach (feeds_importer_load_all() as $importer) {
        $importers[$importer->id] = isset($importer->config['content_type']) ? $importer->config['content_type'] : '';
      }
      cache_set(__FUNCTION__, $importers);
    }
  }
  return $importers;
}

/**
 * Resets importer caches. Call when enabling/disabling importers.
 */
function feeds_cache_clear($rebuild_menu = TRUE) {
  // todo fix this
  cache_clear_all('_feeds_importer_digest', 'cache');
  backdrop_static_reset('_feeds_importer_digest');
  cache_clear_all('plugins:feeds:plugins', 'cache');
  backdrop_static_reset('_node_types_build');
  $cache = &backdrop_static('backdrop_tools_export_load_object');
  $cached_database = &backdrop_static('backdrop_tools_export_load_object_all');
  unset($cache);
  unset($cached_database);
  unset($cached_defaults);
  if ($rebuild_menu) {
    menu_rebuild();
  }
}

/**
 * Logs to a file like /tmp/feeds_my_domain_org.log in temporary directory.
 */
function feeds_dbg($msg) {
  if (config_get('feeds.settings', 'feeds_debug')) {
    if (!is_string($msg)) {
      $msg = var_export($msg, TRUE);
    }
    $filename = trim(str_replace('/', '_', $_SERVER['HTTP_HOST'] . base_path()), '_');
    $handle = fopen("temporary://feeds_$filename.log", 'a');
    fwrite($handle, gmdate('c') . "\t$msg\n");
    fclose($handle);
  }
}

/**
 * Writes to feeds log.
 */
function feeds_log($importer_id, $feed_nid, $type, $message, $variables = array(), $severity = WATCHDOG_NOTICE) {
  if ($severity < WATCHDOG_NOTICE) {
    $error = &backdrop_static('feeds_log_error', FALSE);
    $error = TRUE;
  }
  db_insert('feeds_log')
    ->fields(array(
      'id' => $importer_id,
      'feed_nid' => $feed_nid,
      'log_time' => time(),
      'request_time' => REQUEST_TIME,
      'type' => $type,
      'message' => $message,
      'variables' => serialize($variables),
      'severity' => $severity,
    ))
    ->execute();
}

/**
 * Loads an item info object.
 *
 * Example usage:
 *
 * $info = feeds_item_info_load('node', $node->nid);
 */
function feeds_item_info_load($entity_type, $entity_id) {
  return db_select('feeds_item')
    ->fields('feeds_item')
    ->condition('entity_type', $entity_type)
    ->condition('entity_id', $entity_id)
    ->execute()
    ->fetchObject();
}

/**
 * Inserts an item info object into the feeds_item table.
 */
function feeds_item_info_insert($entity, $entity_id) {
  if (isset($entity->feeds_item)) {
    $entity->feeds_item->entity_id = $entity_id;
    backdrop_write_record('feeds_item', $entity->feeds_item);
  }
}

/**
 * Inserts or updates an item info object in the feeds_item table.
 */
function feeds_item_info_save($entity, $entity_id) {
  if (isset($entity->feeds_item)) {
    $entity->feeds_item->entity_id = $entity_id;
    if (feeds_item_info_load($entity->feeds_item->entity_type, $entity_id)) {
      backdrop_write_record('feeds_item', $entity->feeds_item, array('entity_type', 'entity_id'));
    }
    else {
      feeds_item_info_insert($entity, $entity_id);
    }
  }
}

/**
 * @}
 */

/**
 * @defgroup instantiators Instantiators
 * @{
 */

/**
 * Gets an importer instance.
 *
 * @param string $id
 *   The unique id of the importer object.
 *
 * @return FeedsImporter
 *   A FeedsImporter object or an object of a class defined by the Backdrop
 *   variable 'feeds_importer_class'. There is only one importer object
 *   per $id system-wide.
 */
function feeds_importer($id) {
  return FeedsConfigurable::instance(config_get('feeds.settings', 'feeds_importer_class'), $id);
}

/**
 * Gets an instance of a source object.
 *
 * @param string $importer_id
 *   A FeedsImporter id.
 * @param int $feed_nid
 *   The node id of a feed node if the source is attached to a feed node.
 *
 * @return FeedsSource
 *   A FeedsSource object or an object of a class defined by the Backdrop
 *   variable 'source_class'.
 */
function feeds_source($importer_id, $feed_nid = 0) {
  return FeedsSource::instance($importer_id, $feed_nid);
}

/**
 * Gets an instance of a class for a given plugin and id.
 *
 * @param string $plugin
 *   A string that is the key of the plugin to load.
 * @param string $id
 *   A string that is the id of the object.
 *
 * @return FeedsPlugin
 *   A FeedsPlugin object.
 */
function feeds_plugin($plugin, $id) {

  $plugin_definition = feeds_get_plugins($plugin);

  if (class_exists($plugin_definition['handler']['class'])) {
    $handler = $plugin_definition['handler']['class'];
    return FeedsPlugin::instance($handler, $id, feeds_get_plugins($plugin));
  }

  $args = array('%plugin' => $plugin, '@id' => $id);
  if (user_access('administer feeds')) {
    if (module_exists('feeds_ui')) {
      $args['@link'] = url('admin/structure/feeds/' . $id);
      backdrop_set_message(t('Missing Feeds plugin %plugin. See <a href="@link">@id</a>. Check whether all required libraries and modules are installed properly.', $args), 'warning', FALSE);
    }
    else {
      backdrop_set_message(t('Missing Feeds plugin %plugin used by the importer "@id". Check whether all required libraries and modules are installed properly. Enable the Feeds Admin UI module to check the importer\'s settings.', $args), 'warning', FALSE);
    }
  }
  else {
    backdrop_set_message(t('Missing Feeds plugin %plugin. Please contact your site administrator.', $args), 'warning', FALSE);
  }

  return FeedsPlugin::instance('FeedsMissingPlugin', $id);
}

/**
 * @}
 */

/**
 * @defgroup include functions for loading libraries
 * @{
 */

/**
 * Includes a library file.
 *
 * @param string $file
 *   The filename to load from.
 * @param string $library
 *   The name of the library. If libraries module is installed,
 *   feeds_include_library() will look for libraries with this name managed by
 *   libraries module.
 *
 * @return bool
 *   True if the requested library was found and included with success. False
 *   otherwise.
 */
function feeds_include_library($file, $library) {
  static $included = array();

  $key = $library . '/' . $file;

  if (!isset($included[$key])) {
    $included[$key] = FALSE;

    $library_dir = config_get('feeds.settings', 'feeds_library_dir');
    $feeds_library_path = BACKDROP_ROOT . '/' . backdrop_get_path('module', 'feeds') . "/libraries/$file";
    $libraries_path = module_exists('libraries') ? libraries_get_path($library) : FALSE;

    // Try first whether libraries module is present and load the file from
    // there. If this fails, require the library from the local path.
    if ($libraries_path && is_file("$libraries_path/$file")) {
      require "$libraries_path/$file";
      $included[$key] = TRUE;
    }
    elseif (is_file(BACKDROP_ROOT . '/sites/all/libraries/' . $key)) {
      require BACKDROP_ROOT . '/sites/all/libraries/' . $key;
      $included[$key] = TRUE;
    }
    elseif ($library_dir && is_file($library_dir . '/' . $key)) {
      require $library_dir . '/' . $key;
      $included[$key] = TRUE;
    }
    elseif (is_file($feeds_library_path)) {
      // @todo: Throws "Deprecated function: Assigning the return value of new
      // by reference is deprecated."
      require $feeds_library_path;
      $included[$key] = TRUE;
    }
  }

  return $included[$key];
}

/**
 * Checks whether a library is present.
 *
 * @param string $file
 *   The filename to load from.
 * @param string $library
 *   The name of the library. If libraries module is installed,
 *   feeds_library_exists() will look for libraries with this name managed by
 *   libraries module.
 *
 * @return bool
 *   True if the library exists. False otherwise.
 */
function feeds_library_exists($file, $library) {
  $path = module_exists('libraries') ? libraries_get_path($library) : FALSE;
  if ($path && is_file($path . '/' . $file)) {
    return TRUE;
  }
  elseif (is_file(BACKDROP_ROOT . "/sites/all/libraries/$library/$file")) {
    return TRUE;
  }
  elseif (is_file(BACKDROP_ROOT . '/' . backdrop_get_path('module', 'feeds') . "/libraries/$file")) {
    return TRUE;
  }
  elseif ($library_dir = config_get('feeds.settings', 'feeds_library_dir')) {
    if (is_file("$library_dir/$library/$file")) {
      return TRUE;
    }
  }

  return FALSE;
}

/**
 * Checks whether simplepie exists.
 */
function feeds_simplepie_exists() {
  return (
    feeds_library_exists('autoloader.php', 'simplepie') ||
    feeds_library_exists('library/SimplePie.php', 'simplepie')
  );
}

/**
 * Includes the simplepie library.
 */
function feeds_include_simplepie() {
  $files = array(
    'autoloader.php',
    'library/SimplePie.php',
  );

  foreach ($files as $file) {
    if (feeds_include_library($file, 'simplepie')) {
      return TRUE;
    }
  }

  return FALSE;
}

/**
 * @}
 */

/**
 * Copy of valid_url() that supports the webcal scheme.
 *
 * @see valid_url()
 *
 * @todo Replace with valid_url() when http://drupal.org/node/295021 is fixed.
 */
function feeds_valid_url($url, $absolute = FALSE) {
  if ($absolute) {
    return (bool) preg_match("
      /^                                                      # Start at the beginning of the text
      (?:ftp|https?|feed|webcal):\/\/                         # Look for ftp, http, https, feed or webcal schemes
      (?:                                                     # Userinfo (optional) which is typically
        (?:(?:[\w\.\-\+!$&'\(\)*\+,;=]|%[0-9a-f]{2})+:)*      # a username or a username and password
        (?:[\w\.\-\+%!$&'\(\)*\+,;=]|%[0-9a-f]{2})+@          # combination
      )?
      (?:
        (?:[a-z0-9\-\.]|%[0-9a-f]{2})+                        # A domain name or a IPv4 address
        |(?:\[(?:[0-9a-f]{0,4}:)*(?:[0-9a-f]{0,4})\])         # or a well formed IPv6 address
      )
      (?::[0-9]+)?                                            # Server port number (optional)
      (?:[\/|\?]
        (?:[|\w#!:\.\?\+=&@$'~*,;\/\(\)\[\]\-]|%[0-9a-f]{2})   # The path and query (optional)
      *)?
    $/xi", $url);
  }
  else {
    return (bool) preg_match("/^(?:[\w#!:\.\?\+=&@$'~*,;\/\(\)\[\]\-]|%[0-9a-f]{2})+$/i", $url);
  }
}

/**
 * Registers a feed subscription job for execution on feeds_exit().
 *
 * @param array $job
 *   Information about a new job to queue; or if set to NULL (default), leaves
 *   the current queued jobs unchanged.
 *
 * @return array
 *   An array of subscribe jobs to process.
 *
 * @see feeds_exit()
 * @see feeds_get_subscription_jobs()
 */
function feeds_set_subscription_job(array $job = NULL) {
  $jobs = &backdrop_static(__FUNCTION__, array());
  if (isset($job)) {
    $jobs[] = $job;
  }
  return $jobs;
}

/**
 * Returns the list of queued jobs to be run.
 *
 * @return array
 *   An array of subscribe jobs to process.
 *
 * @see feeds_set_subscription_job()
 */
function feeds_get_subscription_jobs() {
  return feeds_set_subscription_job();
}

/**
 * Implements hook_entity_property_info_alter().
 */
function feeds_entity_property_info_alter(&$info) {

  foreach ($info as $entity_type => $entity_info) {
    $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',
    );
    $info[$entity_type]['properties']['feed_nid'] = array(
      'label' => 'Feed NID',
      'type' => 'integer',
      'description' => t('Nid of the Feed Node that imported this entity.'),
      'getter callback' => 'feeds_get_feeds_item_property',
    );
    $info[$entity_type]['properties']['feed_node'] = array(
      'label' => 'Feed node',
      'type' => 'node',
      'description' => t('Feed Node that imported this entity.'),
      '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);
  if ($entity_id) {
    $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;
    }
  }
}

/**
 * Implements hook_file_download().
 */
function feeds_file_download($uri) {
  $id = db_query("SELECT id FROM {feeds_source} WHERE source = :uri", array(':uri' => $uri))->fetchField();

  if (!$id) {
    // File is not associated with a feed.
    return;
  }

  // Get the file record based on the URI. If not in the database just return.
  $files = file_load_multiple(array(), array('uri' => $uri));
  foreach ($files as $item) {
    // Since some database servers sometimes use a case-insensitive comparison
    // by default, double check that the filename is an exact match.
    if ($item->uri === $uri) {
      $file = $item;
      break;
    }
  }
  if (!isset($file)) {
    return;
  }

  // Check if this file belongs to Feeds.
  $usage_list = file_usage_list($file);
  if (!isset($usage_list['feeds'])) {
    return;
  }

  if (!feeds_access('import', $id)) {
    // User does not have permission to import this feed.
    return -1;
  }

  // Return file headers.
  return file_get_content_headers($file);
}

/**
 * Feeds API version.
 */
function feeds_api_version() {
  return 1;
}

function feeds_load_importer_object($importer_id = NULL) {
  $table = 'feeds_importer';

  $cache = &backdrop_static(__FUNCTION__);

  // If fetching all we are finished.
  if (!$importer_id && $cache) {
    return $cache;
  }

  // Don't load anything we've already cached.
  if (!empty($importer_id) && isset($cache[$importer_id])) {
    return $cache[$importer_id];
  }

  $result = array();
  $config_names = config_get_names_with_prefix('feeds.feeds_importer.');
  foreach ($config_names as $config_file) {
    $config = config($config_file);
    $data = $config->get();
    $result[$data['id']] = $data;
  }


  // Unpack the results of the query onto objects and cache them.
  foreach ($result as $data) {
    $object = new stdClass;
    $object->id = $data['id'];
    $object->config = $data['config'];
    $object->table = $table;
    $object->type = t('Normal');
    $object->disabled = isset($data['disabled'])? $data['disabled']: FALSE;

    $cache[$object->id] = $object;
  }

  // If fetching all, we've done so and we are finished.
  if (!$importer_id) {
    return $cache;
  }

  return !empty($cache[$importer_id]) ? $cache[$importer_id] : NULL;
}

function feeds_get_plugins($plugin = NULL) {
  $plugins = module_invoke_all('feeds_plugins');
  if ($plugin) {
    return $plugins[$plugin];
  }
  return $plugins;
}

function feeds_autoload_info() {
  return array(
  'FeedsAccountSwitcher' => 'includes/FeedsAccountSwitcher.inc',
  'FeedsAccountSwitcherException' => 'includes/FeedsAccountSwitcherException.inc',
  'FeedsConfigurable' => 'includes/FeedsConfigurable.inc',
  'FeedsHTTPCache' => 'includes/FeedsHTTPCache.inc',
  'FeedsHTTPCacheItem' => 'includes/FeedsHTTPCacheItem.inc',
  'FeedsNotExistingException' => 'includes/FeedsConfigurable.inc',
  'FeedsImporter' => 'includes/FeedsImporter.inc',
  'FeedsLockException' => 'includes/FeedsSource.inc',
  'FeedsSource' => 'includes/FeedsSource.inc',
  'FeedsSourceInterface' => 'includes/FeedsSource.inc',
  'FeedsState' => 'includes/FeedsSource.inc',
  'FeedsPreviewSource' => 'includes/FeedsPreviewSource.inc',
  'FeedsPreviewTable' => 'includes/FeedsPreviewTable.inc',
  'HRCurlException' => 'libraries/http_request.inc',

  // Plugins
  'FeedsCSVParser' => 'plugins/FeedsCSVParser.inc',
  'FeedsResult' => 'plugins/FeedsPlugin.inc',
  'FeedsFetcherResult' => 'plugins/FeedsFetcher.inc',
  'FeedsFetcher' => 'plugins/FeedsFetcher.inc',
  'FeedsFileFetcher' => 'plugins/FeedsFileFetcher.inc',
  'FeedsFileFetcherResult' => 'plugins/FeedsFileFetcher.inc',
  'FeedsHTTPFetcher' => 'plugins/FeedsHTTPFetcher.inc',
  'FeedsHTTPFetcherResult' => 'plugins/FeedsHTTPFetcher.inc',
  'FeedsNodeProcessor' => 'plugins/FeedsNodeProcessor.inc',
  'FeedsOPMLParser' => 'plugins/FeedsOPMLParser.inc',
  'FeedsParser' => 'plugins/FeedsParser.inc',
  'FeedsParserResult' => 'plugins/FeedsParser.inc',
  'FeedsTermElement' => 'plugins/FeedsParser.inc',
  'FeedsGeoTermElement' => 'plugins/FeedsParser.inc',
  'FeedsEnclosure' => 'plugins/FeedsParser.inc',
  'FeedsPlugin' => 'plugins/FeedsPlugin.inc',
  'FeedsMissingPlugin' => 'plugins/FeedsPlugin.inc',
  'FeedsProcessor' => 'plugins/FeedsProcessor.inc',
  'FeedsValidationException' => 'plugins/FeedsProcessor.inc',
  'FeedsAccessException' => 'plugins/FeedsProcessor.inc',
  'FeedsProcessorBundleNotDefined' => 'plugins/FeedsProcessor.inc',
  'FeedsSimplePieParser' => 'plugins/FeedsSimplePieParser.inc',
  'FeedsSimplePieEnclosure' => 'plugins/FeedsSimplePieParser.inc',
  'FeedsSitemapParser' => 'plugins/FeedsSitemapParser.inc',
  'FeedsSyndicationParser' => 'plugins/FeedsSyndicationParser.inc',
  'FeedsTermProcessor' => 'plugins/FeedsTermProcessor.inc',
  'FeedsUserProcessor' => 'plugins/FeedsUserProcessor.inc',

  // Views
  'feeds_views_handler_argument_importer_id' => 'views/feeds_views_handler_argument_importer_id.inc',
  'feeds_views_handler_field_importer_name' => 'views/feeds_views_handler_field_importer_name.inc',
  'feeds_views_handler_field_log_message' => 'views/feeds_views_handler_field_log_message.inc',
  'feeds_views_handler_field_severity' => 'views/feeds_views_handler_field_severity.inc',
  'feeds_views_handler_field_source' => 'views/feeds_views_handler_field_source.inc',
  'feeds_views_handler_filter_severity' => 'views/feeds_views_handler_filter_severity.inc',
  'feeds_views_plugin_argument_validate_feed_nid' => 'views/feeds_views_plugin_argument_validate_feed_nid.inc',
  );
}