xpath_field.module

<?php

/**
 * @file
 * Field API funcitons.
 */

/**
 * Implements hook_field_info().
 *
 * Provides the description of the field.
 */
function xpath_field_field_info() {

  return array(
    'xpath_field_xpath' => array(
      'label' => 'XPath Fragment',
      'description' => t('Pick out a fragment of XML from an XML field instance.'),
      'default_widget' => 'text_textfield',
      'default_formatter' => 'xpath_field_safe',
      'storage' => array(
        'type' => 'xpath_field_storage',
        'settings' => array(),
        'module' => 'xpath_field',
        'active' => 1,
      ),
    ),
  );
}

/**
 * Implementation of hook_field_create_field.
 *
 * Sets the field's storage backend to our custom, non-persisting, backend.
 *
 * @param array $field
 */
function xpath_field_field_create_field($field) {
  if ($field['type'] == 'xpath_field_xpath') {
    $field['storage'] = array(
      'type' => 'xpath_field_storage',
      'settings' => array(),
      'module' => 'xpath_field',
      'active' => 1,
    );

    // Build record to update.
    $record = array(
      'id' => $field['id'],
      'storage_type' => $field['storage']['type'],
      'storage_module' => $field['storage']['module'],
      'storage_active' => $field['storage']['active'],
    );

    // Update the field storage.
    $primary_key = array('id');
    drupal_write_record('field_config', $record, $primary_key);
  }
}

/**
 * Implements hook_field_update_field().
 */
function xpath_field_field_update_field($field) {
  xpath_field_field_create_field($field);
}

/**
 * Implementation of hook_storage_info.
 *
 * This info isn't properly saved by Drupal when a new vield instance is created.
 *
 * @see xpath_field_field_create_field for a workaround.
 *
 * @return Array
 */
function xpath_field_field_storage_info() {
  return array(
    'xpath_field_storage' => array(
      'label' => t('XPath derived field storage'),
      'description' => t('Transparent storage of derived XPath fragments.'),
      'settings' => array(),
    ),
  );
}

function xpath_field_field_storage_query(EntityFieldQuery $query) {

}

/**
 * Implementation of hook_field_storage_load().
 *
 * Loads the XML field that this field derives its data from and runs the XPath query
 * to build the field data that attaches to an entity.
 *
 * @param string $entity_type
 * @param array $entities
 * @param int $age
 * @param array $fields
 * @param array $options
 */
function xpath_field_field_attach_load($entity_type, $entities, $age, $options) {
  $load_current = $age == FIELD_LOAD_CURRENT;
  $map = field_info_field_map();
  foreach ($entities as $entity) {
    $bundle_name = property_exists($entity, 'type') ? $entity->type : NULL;
    $entity_info = field_info_instances($entity_type, $bundle_name);

    foreach ($entity as $field_name => $field) {
      if (is_array($entity->{$field_name})
          && array_key_exists($field_name, $map)
          && $map[$field_name]['type'] == 'xpath_field_xpath') {

        $fragments = xpath_field_extract_fragments($entity_type, $entity, $field_name, $field);
        if (!empty($fragments)) {
          // Add the item to the field values for the entity.
          foreach ($fragments as $fragment_index => $fragment) {
            $entity->{$field_name}[$entity->language][] = array('value' => $fragment);
          }
        }
      }
    }
  }
}

function xpath_field_get_xml_data_from_field($xml_field_data, $settings) {
  // XML FIeld puts its data in a key named 'xml'. All other supported
  // fields store their data in 'value'.
  return array_key_exists('xml', $xml_field_data) ? $xml_field_data['xml'] : $xml_field_data['value'];
}

function xpath_field_get_xml_data_from_remote_field($xml_field_data, $settings) {
  $prefix = $settings['url_prefix']['use_default'] ? variable_get('xpath_field_default_url_prefix') : $settings['url_prefix']['prefix'];
  $response = drupal_http_request($prefix . $xml_field_data['value']);
  if ($response->code == '200') {
    return $response->data;
  }
  else {
    watchdog('xpath_field', t('Got error @code form XML data source. Message: @message', array('@code' => $response->code, '@message' => $response->error)), NULL, WATCHDOG_ERROR);
    return FALSE;
  }
}

/**
 * Implementation of hook_widget_info().
 *
 * @return array
 */
function xpath_field_field_widget_info() {
  return array(
    'xpath_field_xpath' => array(
      'label' => t('XPath text'),
      'field types' => array('xpath_field_xpath'),
    ),
  );
}

function _xpath_field_instance_xpath(array $instance) {
  return isset($instance['widget']['settings']['xpath']) ? $instance['widget']['settings']['xpath'] : '';
}

/**
 * Implementation of hook_field_widget_form().
 *
 * Adds extra form elements to the node edit form. These elements are read-only and reflect
 * the result of the field instance's XPath query on the XML field it's been configured to point to.
 *
 * @param array $form
 * @param array $form_state
 * @param array $field
 * @param array $instance
 * @param string $langcode
 * @param array $items
 * @param int $delta
 * @param array $element
 */
function xpath_field_field_widget_form(&$form, &$form_state, $field, $instance, $langcode, $items, $delta, $element) {

  $xpath = _xpath_field_instance_xpath($instance);

  switch ($instance['widget']['type']) {
    case 'xpath_field_xpath':

      $entity = isset($element['#entity']) ? $element['#entity'] : NULL;

      if ($entity) {
        // We are attached to an entity, and not in the widget instance settings form.
        $element['xpath_element'] = array(
          '#type' => 'textfield',
          '#title' => "{$instance['label']} (Derived with $xpath)",
          '#value' => $entity->{$instance['field_name']}[$element['#language']][$delta],
          '#attributes' => array('readonly' => 'readonly'),

        );
        break;
      }
  }

  return $element;
}

/**
 * Implementation of hook_field_formatter_info().
 *
 * @return array
 */
function xpath_field_field_formatter_info() {
  return array(
    // This formatter just displays the hex value in the color indicated.
    'xpath_field_safe' => array(
      'label' => t('Simple text-based formatter'),
      'field types' => array('xpath_field_xpath'),
    ),
  );
}

/**
 * Implementation of hook_field_validate().
 *
 * Always returns true because the user doens't input this field directly.
 */
function xpath_field_field_validate($element, $form_state) {
  return TRUE;
}

/*
 * Field formatter functions.
 */
function xpath_field_field_formatter_info_alter(&$info) {

  $info['text_default']['field types'][] = 'xpath_field_xpath';

}

/**
 * Implementation of hook_field_formatter_view().
 *
 * Puts the XPath field data into a simple markup field.
 *
 * @param string $entity_type
 * @param StdClass $entity
 * @param array $field
 * @param array $instance
 * @param string $langcode
 * @param array $items
 * @param int $display
 *
 * @return array
 */
function xpath_field_field_formatter_view($entity_type, $entity, $field, $instance, $langcode, $items, $display) {
  $element = array();
  switch ($display['type']) {
    case 'xpath_field_safe':
      foreach ($items as $index => $instance) {
        $element[$index] = array(
          '#type' => 'markup',
          '#markup' => $items[$index]['value'],
        );
      }
      break;

  }

  return $element;
}

/**
 * Implement hook_field_widget_settings_form().
 *
 * Adds settings for XML Field and XPath value.
 */
function xpath_field_field_widget_settings_form($field, $instance) {

  $widget = $instance['widget'];
  $settings = $widget['settings'];

  $form = array();
  $form['xml_field_instance'] = array(
    '#type' => 'select',
    '#title' => t('Attach to XML Field'),
    '#description' => t('Select the XML field instance on this content type to grab an XPath value from.'),
  );

  $xml_field_instances = array();
  foreach (field_info_field_map() as $index => $other_field) {
    if (in_array($other_field['type'], array('xml_field_xml', 'text', 'text_long', 'text_with_summary'))) {
      foreach ($other_field['bundles'] as $other_field_bundle_type_name => $other_field_bundle_type) {
        foreach ($other_field_bundle_type as $other_field_bundle) {
          if ($other_field_bundle == $instance['bundle']) {
            $field_info = field_info_instance($other_field_bundle_type_name, $index, $other_field_bundle);
            $form['xml_field_instance']['#options'][$index] = $field_info['label'] . " ($index)";
          }
        }
      }
    }
  }
  $form['is_remote_path'] = array(
    '#type' => 'checkbox',
    '#title' => 'Field is remote path.',
    '#description' => 'This field contains the path identifier from which to retrieve the XML content.',
    '#default_value' => isset($settings['is_remote_path']) ? $settings['is_remote_path'] : FALSE,
  );
  $form['url_prefix'] = array(
    '#type' => 'fieldset',
    '#title' => 'Remote field URL Prefix',
  );
  $form['url_prefix']['use_default'] = array(
    '#type' => 'checkbox',
    '#title' => t('Use default (@default)', array('@default' => variable_get('xpath_field_default_url_prefix'))),
    '#default_value' => isset($settings['url_prefix']['use_default']) ? $settings['url_prefix']['use_default'] : TRUE,
  );
  $form['url_prefix']['prefix'] = array(
    '#type' => 'textfield',
    '#title' => t('Or, use a custom URL prefix for this field instance'),
    '#description' => t('If this is a remote XML path, this is the prefix to attach the path to to retrieve the document.'),
    '#default_value' => isset($settings['url_prefix']['prefix']) ? $settings['url_prefix']['prefix'] : '',
  );
  if (array_key_exists('xml_field_instance', $settings)) {
    $form['xml_field_instance']['#default_value'] = $settings['xml_field_instance'];
  }

  $xsl_formatter_enabled = module_exists('xsl_formatter');

  $form['use_xslt'] = array(
    '#title' => t('Use an XSL transformation.'),
    '#type' => 'select',
    '#description' => t('Choose an XSLT stylesheet to use to transform the XML content.'),
    '#options' => array(
      'xpath' => 'XPath query',
      'xslt' => 'XSLT transformation',
    ),
    '#access' => $xsl_formatter_enabled,
    '#default_value' => isset($settings['use_xslt']) ? $settings['use_xslt'] : 'xpath',
  );

  $xsl_enabled_states = array(
    'enabled' => array(
      ':input[name="instance[widget][settings][use_xslt]"]' => array('value' => 'xslt'),
    ),
  );

  $xsls = $xsl_formatter_enabled ? xsl_formatter_enumerate_xsls() : array();
  $form['xsl_path'] = array(
    '#title' => t('XSL path'),
    '#type' => 'select',
    '#default_value' => (isset($settings['xsl_path']) ? $settings['xsl_path'] : ""),
    '#element_validate' => array('xpath_field_xsl_path_validate'),
    '#description' => t("Path to the location of the XSL file. Search will be made relative to the files/xsl directory, then the module directory."),
    '#options' => $xsls,
    '#required' => FALSE,
    '#states' => $xsl_enabled_states,
    '#access' => $xsl_formatter_enabled,
  );

  // file upload needs an explicit name. This is horrid sorry.
  $upload_field_id = 'files[' . drupal_clean_css_identifier("files[instance][widget][settings][xsl_upload]") . ']';
  $form['xsl_upload'] = array(
    '#type' => 'file',
    '#title' => t('Upload XSL file'),
    '#maxlength' => 40,
    '#description' => t("This will be placed in your files/xsl folder where it can be found and re-used."),
    '#element_validate' => $xsl_formatter_enabled ? array('xsl_formatter_xsl_upload_validate') : array(),
    '#name' => $upload_field_id,
    '#states' => $xsl_enabled_states,
    '#access' => $xsl_formatter_enabled,
  );
  $module_path = drupal_get_path('module', 'xsl_formatter');
  $form['xsl_params'] = array(
    '#title' => t('Additional params'),
    '#type' => 'textarea',
    '#rows' => 2,
    '#cols' => 24,
    '#description' => t("Additional parameters that the Transformation stylesheet may expect. Use JSON format, eg <pre>{\"indent-elements\":true, \"css-stylesheet\":\"$module_path/xsl/xmlverbatim.css\"}</pre>"),
    '#default_value' => (isset($settings['xsl_params']) ? $settings['xsl_params'] : ""),
    '#element_validate' => $xsl_formatter_enabled ? array('xsl_formatter_xsl_params_validate') : array(),
    '#states' => $xsl_enabled_states,
    '#access' => $xsl_formatter_enabled,
  );
  $form['debug'] = array(
    '#title' => t('Show XML parsing warnings'),
    '#type' => 'checkbox',
    '#description' => t("Bad XML data input will trigger warnings that may show on screen. Disable this for a public site."),
    '#default_value' => (isset($settings['debug']) ? $settings['debug'] : 0),
    '#states' => $xsl_enabled_states,
    '#access' => $xsl_formatter_enabled,
  );

  $form['xpath'] = array(
    '#type' => 'textfield',
    '#title' => t('XPath value'),
    '#description' => t('Enter the XPath to select a fragment from the XML Field instance.'),
    '#default_value' => array_key_exists('xpath', $settings) ? $settings['xpath'] : '',
    '#states' => array(
      'enabled' => array(
        ':input[name="instance[widget][settings][use_xslt]"]' => array('value' => 'xpath'),
      ),
    ),
  );

  $form['xpath_text_only'] = array(
    '#type' => 'checkbox',
    '#title' => t('Only use text content'),
    '#description' => t('Return the text contents of the node specified by the XPath query instead of the actual element.  Equivalent to "/text()" at the end of your xpath.'),
    '#default_value' => isset($settings['xpath_text_only']) ? $settings['xpath_text_only'] : 1,
    '#states' => array(
      'enabled' => array(
        ':input[name="instance[widget][settings][use_xslt]"]' => array('value' => 'xpath'),
      ),
    ),
  );

  return $form;
}

/**
 * Ensure the named path exists. This includes a small search lookup.
 */
function xpath_field_xsl_path_validate($element, &$form_state, $form) {
  $settings = $form_state['values']['instance']['widget']['settings'];
  if ($settings['use_xslt'] === 'xslt') {
    xsl_formatter_xsl_path_validate($element, $form_state, $form);
  }
}

/**
 * Implementation of hook_form_field_ui_field_edit_form_alter().
 * Add a submit handler so we can clear Drupal's field cache.
 *
 * @param array $form
 * @param array $form_state
 */
function xpath_field_form_field_ui_field_edit_form_alter(&$form, &$form_state) {
  if ($form['#field']['module'] == 'xpath_field') {
    $form['#submit'][] = 'xpath_field_widget_settings_form_submit';
  }
}

/**
 * Since Drupal caches field contents we need to clear the field cache when the
 * user changes the field settings.
 *
 * @param array $form
 * @param array $form_state
 */
function xpath_field_widget_settings_form_submit($form, &$form_state) {
  drupal_set_message(t('The field cache has been cleared.'));
  field_cache_clear();
}

/**
 * Implementation of hook_field_is_empty().
 *
 * Always FALSE because the field's value is populated dynamically.
 */
function xpath_field_field_is_empty($item, $field) {
  return FALSE;
}

/*
 * XML utility functions.
 */

/**
 * Runs an XPath query against the XML Field and returns the SimpleXMLElement containing
 * the results.
 *
 * @param string $xml_string
 * @param string $xpath
 * @param bool $text_only
 *
 * @return string The XML result.
 */
function xpath_field_get_xpath_fragment($xml_string, $xpath, $text_only) {
  $results = array();
  $resultsXML = array();
  try {
    $xml = new SimpleXMLElement($xml_string);
    $results = $xml->xpath($xpath);
  }
  catch (Exception $e) {
    drupal_set_message($e->getMessage());
  }
  if (!empty($results)) {
    foreach ($results as $result) {
      if ($text_only) {
        $resultsXML[] = (string)$result;
      }
      else {
        $resultsXML[] = $result->asXml();
      }
    }
  }
  return $resultsXML;
}

function xpath_field_apply_xsl_transformation($xml_string, $xsl_path, $xsl_params, $debug = FALSE) {
  $xml_doc = new DomDocument();
  try {
    if ($debug) {
      $xml_doc->loadXml($xml_string);
    }
    else {
      @$xml_doc->loadXml($xml_string);
    }

    $xsl_doc = xsl_formatter_get_xml_doc($xsl_path);
    $params = (array) json_decode($xsl_params);
    // 'base' can be used for supporting relative css links.
    $params['base'] = url(dirname($xsl_doc->documenturi));
    // Transform.
    $result = xsl_formatter_xmldoc_plus_xsldoc($xml_doc, $xsl_doc, $params);
  }
  catch (Exception $e) {
    watchdog('xpath_field', "Unable to parse the XML data or transform it. %message", array('%message' => $e->getMessage()), E_USER_ERROR);
  }
  return $result;
}

function xpath_field_get_xml_extractor($settings) {
  if ($settings['is_remote_path'] == TRUE) {
    $xml_extractor = 'xpath_field_get_xml_data_from_remote_field';
  }
  else {
    $xml_extractor = 'xpath_field_get_xml_data_from_field';
  }
  return $xml_extractor;
}

function xpath_field_extract_fragments($entity_type, $entity, $field_name, $field) {
  $field_instance = field_info_instance($entity_type, $field_name, $entity->type);
  $settings = $field_instance['widget']['settings'];
  $xml_extractor = xpath_field_get_xml_extractor($settings);

  $xml_field_instance = isset($settings['xml_field_instance']) ? $settings['xml_field_instance'] : NULL;
  if ($xml_field_instance) {
    $lang = property_exists($entity, 'language') ? $entity->language : NULL;
    $xpath = _xpath_field_instance_xpath($field_instance);
    if ($lang !== NULL) {
      foreach ($entity->{$xml_field_instance}[$lang] as $xml_field_data) {
        $xml = $xml_extractor($xml_field_data, $settings);

        switch ($settings['use_xslt']) {
          case 'xpath':
            $fragments = xpath_field_get_xpath_fragment($xml, $xpath, $settings['xpath_text_only']);
            break;

          case 'xslt':
            $fragments = array(xpath_field_apply_xsl_transformation($xml, $settings['xsl_path'], $settings['xsl_params']));
            break;
        }
      }
    }
  }
  return $fragments;
}

/**
 * If we upload our own xsl, Make sure it gets saved.
 *
 * Place it in the public xsl foilder and refer to it.
 */
function xpath_field_xsl_upload_validate($element, &$form_state, $form) {
  // Check for a new uploaded xsl.
  // Figure out what the big ID was. This is wierd.
  $upload_field_id = 'files-' . substr($element['#id'], strlen('edit-'));

  // Get it. Temporary at first.
  $validators = array('file_validate_extensions' => array('xsl', 'xslt'));
  $file = file_save_upload($upload_field_id, $validators);

  if (!empty($file)) {
    // File upload was attempted.
    if ($file) {
      $save_dir  = "public://xsl";
      file_prepare_directory($save_dir, FILE_CREATE_DIRECTORY);
      $save_filepath = $save_dir . '/' . $file->filename;
      $filename = file_unmanaged_copy($file->uri, $save_filepath, FILE_EXISTS_REPLACE);

      // Set xsl_path to the newly uploaded value.
      // The #parents array is important.
      // Find the nearby xsl_path element with the same ancestry as me.
      $parents = $element['#parents'];
      array_pop($parents);
      array_push($parents, 'xsl_path');
      $xsl_path_element = array('#parents' => $parents);
      form_set_value($xsl_path_element, $save_filepath, $form_state);
    }
    else {
      // File upload failed.
      form_set_error('xsl_upload', t('The xsl could not be uploaded.'));
    }
  }
}


/*
 * Drupal admin menu functions.
 */

/**
 * Implementation of hook_menu().
 */
function xpath_field_menu() {
  $menu = array(
    'admin/config/content/xpath-field' => array(
      'title' => t('XPath Field'),
      'description' => t('XPath Field global settings.'),
      'page callback' => 'drupal_get_form',
      'page arguments' => array('xpath_field_settings_form'),
      'access arguments' => array('access administration pages'),
    ),
  );
  return $menu;
}

function xpath_field_settings_form($form, &$form_state) {
  $form['xpath_field_default_url_prefix'] = array(
    '#type' => 'textfield',
    '#title' => t('Default URL prefix'),
    '#description' => t('For XML fields stored on remote servers, you can provide a default root URL that paths in field data will be appended to. E.g., "http://www.example.com/xml". If the field value contains a leading slash, then don\'t include a trailing slash in this field.'),
    '#default_value' => variable_get('xpath_field_default_url_prefix'),
    '#required' => FALSE,
  );

  $form['submit'] = array(
    '#type' => 'submit',
    '#value' => t('Save'),
  );

  return $form;
}

function xpath_field_settings_form_submit($form, &$form_state) {
  variable_set('xpath_field_default_url_prefix', $form_state['values']['xpath_field_default_url_prefix']);
  drupal_set_message(t('Saved XPath field settings.'), 'status');
}