<?php
// $Id: feeds.module,v 1.74.2.11 2010-10-27 19:53:21 alexb Exp $

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

// Common request time, use as point of reference and to avoid calls to time().
define('FEEDS_REQUEST_TIME', time());
// Do not schedule a feed for refresh.
define('FEEDS_SCHEDULE_NEVER', -1);
// Never expire feed items.
define('FEEDS_EXPIRE_NEVER', -1);
// An object that is not persistent. Compare EXPORT_IN_DATABASE, EXPORT_IN_CODE.
define('FEEDS_EXPORT_NONE', 0x0);
// Status of batched operations.
define('FEEDS_BATCH_COMPLETE', 1.0);
define('FEEDS_BATCH_ACTIVE', 0.0);

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

/**
 * Implements hook_cron().
 */
function feeds_cron() {
  if ($importers = feeds_reschedule()) {
    foreach ($importers as $id) {
      feeds_importer($id)->schedule();
      $rows = db_query("SELECT feed_nid FROM {feeds_source} WHERE id = :id", array(':id' => $id));
      foreach ($rows as $row) {
        feeds_source($id, $row->feed_nid)->schedule();
      }
    }
    feeds_reschedule(FALSE);
  }
  // Expire old log entries.
  db_delete('feeds_log')
    ->condition('request_time', REQUEST_TIME - 604800, '<')
    ->execute();
}

/**
 * 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',
  );
  $info['feeds_source_clear'] = array(
    'queue name' => 'feeds_source_clear',
  );
  $info['feeds_importer_expire'] = array(
    'queue name' => 'feeds_importer_expire',
  );
  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' => 15,
  );
  $queues['feeds_source_clear'] = array(
    'worker callback' => 'feeds_source_clear',
    'time' => 15,
  );
  $queues['feeds_importer_expire'] = array(
    'worker callback' => 'feeds_importer_expire',
    'time' => 15,
  );
  return $queues;
}

/**
 * Scheduler callback for importing from a source.
 */
function feeds_source_import($job) {
  $source = feeds_source($job['type'], $job['id']);
  try {
    $source->existing()->import();
  }
  catch (FeedsNotExistingException $e) {}
  catch (Exception $e) {
    $source->log('import', $e->getMessage(), array(), WATCHDOG_ERROR);
  }
  $source->scheduleImport();
}

/**
 * Scheduler callback for deleting all items from a source.
 */
function feeds_source_clear($job) {
  $source = feeds_source($job['type'], $job['id']);
  try {
    $source->existing()->clear();
  }
  catch (FeedsNotExistingException $e) {}
  catch (Exception $e) {
    $source->log('clear', $e->getMessage(), array(), WATCHDOG_ERROR);
  }
  $source->scheduleClear();
}

/**
 * Scheduler callback for expiring content.
 */
function feeds_importer_expire($job) {
  $importer = feeds_importer($job['type']);
  try {
    $importer->existing()->expire();
  }
  catch (FeedsNotExistingException $e) {}
  catch (Exception $e) {
    $importer->log('expire', $e->getMessage(), array(), WATCHDOG_ERROR);
  }
  $importer->scheduleExpire();
}

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

/**
 * Reschedule one or all importers.
 *
 * @param $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
 *   TRUE if all importers need rescheduling. FALSE if no rescheduling is
 *   required. An array of importers that need rescheduling.
 */
function feeds_reschedule($importer_id = NULL) {
  $reschedule = variable_get('feeds_reschedule', FALSE);
  if ($importer_id === TRUE || $importer_id === FALSE) {
    $reschedule = $importer_id;
  }
  elseif (is_string($importer_id) && $reschedule !== TRUE) {
    $reschedule = is_array($reschedule) ? $reschedule : array();
    $reschedule[$importer_id] = $importer_id;
  }
  variable_set('feeds_reschedule', $reschedule);
  if ($reschedule === TRUE) {
    return feeds_enabled_importers();
  }
  return $reschedule;
}

/**
 * Implements feeds_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'])),
    );
  }
  return $perms;
}

/**
 * Implements hook_forms().
 *
 * Declare form callbacks for all known classes derived from FeedsConfigurable.
 */
function feeds_forms() {
  $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' => 'Import',
    'page callback' => 'feeds_page',
    'access callback' => 'feeds_page_access',
    'file' => 'feeds.pages.inc',
  );
  $items['import/%'] = array(
    'title callback' => 'feeds_importer_title',
    'title arguments' => array(1),
    'page callback' => 'drupal_get_form',
    'page arguments' => array('feeds_import_form', 1),
    'access callback' => 'feeds_access',
    'access arguments' => array('import', 1),
    'file' => 'feeds.pages.inc',
  );
  $items['import/%/import'] = array(
    'title' => 'Import',
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'weight' => -10,
  );
  $items['import/%/delete-items'] = array(
    'title' => 'Delete items',
    'page callback' => 'drupal_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/%/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' => 'drupal_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' => 'drupal_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,
  );
  // @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;
}

/**
 * Menu loader callback.
 */
function feeds_importer_load($id) {
  return feeds_importer($id);
}

/**
 * Title callback.
 */
function feeds_importer_title($id) {
  $importer = feeds_importer($id);
  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 $action
 *   One of 'import' or 'clear'.
 * @param $param
 *   Node object or FeedsImporter id.
 */
function feeds_access($action, $param) {
  if (is_string($param)) {
    $importer_id = $param;
  }
  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;
}

/**
 * Menu access callback.
 */
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() {
  if (drupal_static('feeds_log_error', FALSE)) {
    watchdog('feeds', 'Feeds reported errors, visit the Feeds log for details.', array(), WATCHDOG_ERROR, 'admin/reports/dblog/feeds');
  }
}

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

/**
 * Implements hook_ctools_plugin_api().
 */
function feeds_ctools_plugin_api($owner, $api) {
  if ($owner == 'feeds' && $api == 'plugins') {
    return array('version' => 1);
  }
}

/**
 * Implements hook_ctools_plugin_type().
 */
function feeds_ctools_plugin_type() {
  return array(
    'plugins' => array(
      'cache' => TRUE,
      'use hooks' => TRUE,
      'classes' => array('handler'),
    ),
  );
}

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

/**
 * 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 = &drupal_static('feeds_node_last_title');
  $last_feeds = &drupal_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);

  // If node title is empty, try to retrieve title from feed.
  if (trim($node->title) == '') {
    try {
      $source->addConfig($last_feeds);
      if (!$last_title = $source->preview()->title) {
        throw new Exception();
      }
    }
    catch (Exception $e) {
      drupal_set_message($e->getMessage(), 'error');
      form_set_error('title', t('Could not retrieve title from feed.'), 'error');
    }
  }
}

/**
 * Implements hook_node_presave().
 */
function feeds_node_presave($node) {
  // Populate $node->title and $node->feed from result of validation phase.
  $last_title = &drupal_static('feeds_node_last_title');
  $last_feeds = &drupal_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;
}

/**
 * Implements hook_node_insert().
 */
function feeds_node_insert($node) {
  // Node produced by source.
  feeds_item_info_insert($node, $node->nid);

  // Source attached to node.
  feeds_node_update($node);
  if ($importer_id = feeds_get_importer_id($node->type)) {
    $source = feeds_source($importer_id, $node->nid);
    // Start import if requested.
    if (feeds_importer($importer_id)->config['import_on_create'] && !isset($node->feeds['suppress_import'])) {
      $source->startImport();
    }
    // Schedule source and importer.
    $source->schedule();
    feeds_importer($importer_id)->schedule();
  }
}

/**
 * Implements hook_node_update().
 */
function feeds_node_update($node) {
  // Node produced by source.
  feeds_item_info_update($node, $node->nid);

  // Source attached to node.
  if ($importer_id = feeds_get_importer_id($node->type)) {
    $source = feeds_source($importer_id, $node->nid);
    $source->addConfig($node->feeds);
    $source->save();
  }
}

/**
 * Implements hook_node_delete().
 */
function feeds_node_delete($node) {
  // Node produced by source.
  db_delete('feeds_item')
    ->condition('entity_type', 'node')
    ->condition('entity_id', $node->nid)
    ->execute();
  // 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_taxonomy_term_insert().
 */
function feeds_taxonomy_term_insert($term) {
  feeds_item_info_insert($term, $term->tid);
}

/**
 * Implements hook_taxonomy_term_update().
 */
function feeds_taxonomy_term_update($term) {
  feeds_item_info_update($term, $term->tid);
}

/**
 * Implements hook_taxonomy_delete().
 */
function feeds_taxonomy_term_delete($term) {
  db_delete('feeds_item')
    ->condition('entity_type', 'taxonomy_term')
    ->condition('entity_id', $term->tid)
    ->execute();
}

/**
 * Implements hook_user_insert().
 */
function feeds_user_insert(&$edit, $account, $category) {
  feeds_item_info_insert($account, $account->uid);
}

/**
 * Implements hook_user_update().
 */
function feeds_user_update(&$edit, $account, $category) {
  feeds_item_info_update($account, $account->uid);
}

/**
 * Implements hook_user_delete().
 */
function feeds_user_delete($account) {
  db_delete('feeds_item')
    ->condition('entity_type', 'user')
    ->condition('entity_id', $account->uid)
    ->execute();
}

/**
 * Implements hook_form_alter().
 */
function feeds_form_alter(&$form, $form_state, $form_id) {
  if (!empty($form['#node_edit_form'])) {
    if ($importer_id = feeds_get_importer_id($form['type']['#value'])) {
      // Set title to not required, try to retrieve it from feed.
      $form['title']['#required'] = FALSE;
      // Enable uploads.
      $form['#attributes']['enctype'] = 'multipart/form-data';

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

/**
 * @}
 */

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

/**
 * Loads all importers.
 *
 * @param $load_disabled
 *   Pass TRUE to load all importers, enabled or disabled, pass FALSE to only
 *   retrieve enabled importers.
 *
 * @return
 *   An array of all feed configurations available.
 */
function feeds_importer_load_all($load_disabled = FALSE) {
  $feeds = array();
  // This function can get called very early in install process through
  // menu_router_rebuild(). Do not try to include CTools if not available.
  if (function_exists('ctools_include')) {
    ctools_include('export');
    $configs = ctools_export_load_object('feeds_importer', 'all');
    foreach ($configs as $config) {
      if (!empty($config->id) && ($load_disabled || empty($config->disabled))) {
        $feeds[$config->id] = feeds_importer($config->id);
      }
    }
  }
  return $feeds;
}

/**
 * Gets an array of enabled importer ids.
 *
 * @return
 *   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 $content_type
 *   A node type string.
 *
 * @return
 *   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 = &drupal_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) {
  cache_clear_all('_feeds_importer_digest', 'cache');
  drupal_static_reset('_feeds_importer_digest');
  ctools_include('export');
  ctools_export_load_object_reset('feeds_importer');
  drupal_static_reset('_node_types_build');
  if ($rebuild_menu) {
    menu_rebuild();
  }
}

/**
 * Exports a FeedsImporter configuration to code.
 */
function feeds_export($importer_id, $indent = '') {
  ctools_include('export');
  $result = ctools_export_load_object('feeds_importer', 'names', array('id' => $importer_id));
  if (isset($result[$importer_id])) {
    return ctools_export_object('feeds_importer', $result[$importer_id], $indent);
  }
}

/**
 * Logs to a file like /mytmp/feeds_my_domain_org.log in temporary directory.
 */
function feeds_dbg($msg) {
  if (variable_get('feeds_debug', false)) {
    if (!is_string($msg)) {
      $msg = var_export($msg, true);
    }
    $filename = trim(str_replace('/', '_', $_SERVER['HTTP_HOST'] . base_path()), '_');
    $handle = fopen(file_directory_temp() ."/feeds_$filename.log", 'a');
    fwrite($handle, date('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 = &drupal_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()
    ->fetch();
}

/**
 * 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;
    drupal_write_record('feeds_item', $entity->feeds_item);
  }
}

/**
 * Updates an item info object in he feeds_item table.
 */
function feeds_item_info_update($entity, $entity_id) {
  if (isset($entity->feeds_item)) {
    $entity->feeds_item->entity_id = $entity_id;
    drupal_write_record('feeds_item', $entity->feeds_item, array('entity_type', 'entity_id'));
  }
}

/**
 * @}
 */

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

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

/**
 * Gets an instance of a source object.
 *
 * @param $importer_id
 *   A FeedsImporter id.
 * @param $feed_nid
 *   The node id of a feed node if the source is attached to a feed node.
 *
 * @return
 *   A FeedsSource object or an object of a class defiend by the Drupal
 *   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 $plugin
 *   A string that is the key of the plugin to load.
 * @param $id
 *   A string that is the id of the object.
 *
 * @return
 *   A FeedsPlugin object.
 *
 * @throws Exception
 *   If plugin can't be instantiated.
 */
function feeds_plugin($plugin, $id) {
  ctools_include('plugins');
  if ($class = ctools_plugin_load_class('feeds', 'plugins', $plugin, 'handler')) {
    return FeedsConfigurable::instance($class, $id);
  }
  $args = array( '%plugin' => $plugin);
  if (user_access('administer feeds')) {
    $args['!link'] = l($id, 'admin/structure/feeds/edit/' . $id);
    drupal_set_message(t('Missing Feeds plugin %plugin. See !link. Check whether all required libraries and modules are installed properly.', $args), 'warning');
  }
  else {
    drupal_set_message(t('Missing Feeds plugin %plugin. Please contact your site administrator.', $args), 'warning');
  }
  $class = ctools_plugin_load_class('feeds', 'plugins', 'FeedsMissingPlugin', 'handler');
  return FeedsConfigurable::instance($class, $id);
}

/**
 * @}
 */

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

/**
 * Includes a library file.
 *
 * @param $file
 *   The filename to load from.
 * @param $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.
 */
function feeds_include_library($file, $library) {
  static $included = array();
  if (!isset($included[$file])) {
    // Try first whether libraries module is present and load the file from
    // there. If this fails, require the library from the local path.
    if (module_exists('libraries') && file_exists(libraries_get_path($library) . "/$file")) {
      require libraries_get_path($library) ."/$file";
    }
    else {
      // @todo: Throws "Deprecated function: Assigning the return value of new
      // by reference is deprecated."
      require DRUPAL_ROOT . '/' . drupal_get_path('module', 'feeds') . "/libraries/$file";
    }
  }
  $included[$file] = TRUE;
}

/**
 * Checks whether a library is present.
 *
 * @param $file
 *   The filename to load from.
 * @param $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.
 */
function feeds_library_exists($file, $library) {
  if (module_exists('libraries') && file_exists(libraries_get_path($library) . "/$file")) {
    return TRUE;
  }
  elseif (file_exists(DRUPAL_ROOT . '/' . drupal_get_path('module', 'feeds') . "/libraries/$file")) {
    return TRUE;
  }
  return FALSE;
}

/**
 * Simplified drupal_alter().
 *
 * - None of that 'multiple parameters by ref' crazyness.
 * - Don't use module_implements() to allow hot including on behalf
 *   implementations (see mappers/).
 */
function feeds_alter($type, &$data) {
  $args = array(&$data);
  $additional_args = func_get_args();
  array_shift($additional_args);
  array_shift($additional_args);
  $args = array_merge($args, $additional_args);

  $list = module_list();
  foreach (module_list() as $module) {
    $function = $module .'_'. $type .'_alter';
    if (function_exists($function)) {
      call_user_func_array($function, $args);
    }
  }
}

/**
 * @}
 */