modules/metrics/metrics.module

<?php
// $Id: metrics.module,v 1.4 2007/08/20 18:52:19 drewish Exp $

/**
 * Implementation of hook_help().
 */
function metrics_help($section) {
  switch ($section) {
    case 'admin/help#metrics':
      return t("<p>Overview of the parts of Metrics.</p>
<dl>
<dt>Metric</dt>
<dt>A metric is a function that takes a node and computes a numeric score and an explanatory string.</dt>
<dt>Ranking</dt>
<dt>A ranking has a name, a numeric threshold, and a description. The ranking's purpose is to help a user interpret a property's score. Is a score of 30 is good or bad?</dt>
<dt>Property</dt>
<dt>A property has a name and a description to explain what it measures. The property is made up of metrics and rankings. Each metric within the property can have options and a multiplier. The multiplier is used to adjust the importance of each metric in the overall score.</dt>
<dt>Property result</dt>
<dt>When a property is computed for a node, each metrics is evaluated, the numeric value multiplied by the multiplier then added to the total, and the explanatory strings concatenated. This is stored in the database and displayed in a block on the node's page.</dt>
</dl>
<p>The property results are computed during a cron run by first looking for missing results and then updating the most out of date. The administrator can determine how frequently the properties are updated and how many are updated in a single cron run.</p>
");
  }
}

/**
 * Implementation of hook_menu().
 */
function metrics_menu($may_cache) {
  $items = array();

  if ($may_cache) {
    $items[] = array(
      'path' => 'admin/content/metrics',
      'title' => t('Metrics'),
      'callback' => 'metrics_admin_overview',
      'description' => t('Configure the settings used to rate node quality.'),
    );
    $items[] = array(
      'path' => 'admin/content/metrics/list',
      'title' => t('List'),
      'type' => MENU_DEFAULT_LOCAL_TASK,
      'weight' => '-10',
    );
    $items[] = array(
      'path' => 'admin/content/metrics/add',
      'callback' => 'drupal_get_form',
      'callback arguments' => array('metrics_property_form'),
      'title' => t('Add'),
      'type' => MENU_LOCAL_TASK,
    );
    $items[] = array(
      'path' => 'admin/settings/metrics',
      'title' => t('Metrics'),
      'callback' => 'drupal_get_form',
      'callback arguments' => array('metrics_settings_form'),
      'description' => t('Configure the settings used to rate node quality.'),
    );
  }
  else {
    if (arg(0) == 'admin' && arg(1) == 'content' && arg(2) == 'metrics' && is_numeric(arg(3))) {
      $property_id = (int) arg(3);
      if ($property = metrics_get_property($property_id)) {
      
        $items[] = array(
          'path' => 'admin/content/metrics/'. $property_id,
          'title' => t('Property'),
          'callback' => 'metrics_property_overview',
          'callback arguments' => array($property_id),
          'type' => MENU_CALLBACK,
        );
        $items[] = array(
          'path' => 'admin/content/metrics/'. $property_id .'/view',
          'title' => t('View'),
          'type' => MENU_DEFAULT_LOCAL_TASK,
          'weight' => -10,
        );
        $items[] = array(
          'path' => 'admin/content/metrics/'. $property_id .'/edit',
          'title' => t('Edit'),
          'callback' => 'metrics_property_edit',
          'callback arguments' => array($property_id),
          'type' => MENU_LOCAL_TASK,
        );
        $items[] = array(
          'path' => 'admin/content/metrics/'. $property_id .'/metrics',
          'title' => t('Metrics'),
          'callback' => 'drupal_get_form',
          'callback arguments' => array('metrics_metrics_form', $property),
          'type' => MENU_LOCAL_TASK,
        );
        $items[] = array(
          'path' => 'admin/content/metrics/'. $property_id .'/rankings',
          'title' => t('Rankings'),
          'callback' => 'drupal_get_form',
          'callback arguments' => array('metrics_rankings_form', $property),
          'type' => MENU_LOCAL_TASK,
        );
        $items[] = array(
          'path' => 'admin/content/metrics/'. $property_id .'/delete',
          'title' => t('Delete'),
          'callback' => 'drupal_get_form',
          'callback arguments' => array('metrics_metric_delete_form', $property_id),
          'type' => MENU_CALLBACK,
        );
      }
    }
  }

  return $items;
}


/**
 * Implementation of hook_block().
 */
function metrics_block($op = 'list', $delta = 0, $edit = array()) {
  switch ($op) {
    case 'list':
      $blocks[0] = array(
        'info'       => t('Project Metrics'),
        'status'     => TRUE,
        'weight'     => 0,
        'visibility' => 1,
        'pages'      => 'node/*',
      );
      return $blocks;

    case 'configure':
      return $form;

    case 'view': 
    default:
      switch ($delta) {
        case 0:
          if ($output = metrics_block_display((int) arg(1))) {
            return array(
              'subject' => t('Project metrics...'),
              'content' => $output,
            );
          }
          break;

        default:
          return array();
      } 
  }
}


function metrics_block_display($nid) {
  if ($node = node_load($nid)) {
    $items = array();
    foreach ((array) $node->metrics as $property_id => $result) {
      $items[] = t('@metric<br /><strong>Score: @score</strong><br />@description', array('@metric' => $result['name'], '@score' => $result['value'], '@description' => $result['description']));
    }
    if ($items) {
      return theme('item_list', $items);
    }
  }
}

/**
 * Implementation of hook_cron().
 */
function metrics_cron() {
  $limit = variable_get('metrics_cron_limit', 50);
  $timestamp = time() - variable_get('metrics_recompute_after', 604800);

  // Locate nodes without {metrics_property_result} records.
  $result = db_query_range('SELECT mpnt.property_id, n.nid FROM {metrics_property_node_types} mpnt INNER JOIN {node} n ON mpnt.type = n.type AND n.status = 1 WHERE NOT EXISTS 
      ( SELECT * FROM {metrics_property_result} mpr WHERE mpr.property_id = mpnt.property_id AND mpr.nid = n.nid )', 0, $limit);
  while ($row = db_fetch_object($result)) {
    if ($node = node_load($row->nid)) {
      metrics_compute_property($row->property_id, $node);
    }
  }

  // Count the preceding rows against the limit.  
  $limit -= db_num_rows($result);
  if ($limit < 1) {
    return;
  }

  // Update stale records.
  $result = db_query_range('SELECT mpr.nid, mpr.property_id FROM {metrics_property_result} mpr INNER JOIN {node} n ON mpr.nid = n.nid WHERE mpr.timestamp < %d AND n.status = 1', $timestamp, 0, $limit);
  while ($row = db_fetch_object($result)) {
    if ($node = node_load($row->nid)) {
      metrics_compute_property($row->property_id, $node);
    }
  }
}


/**
 * Implementation of hook_nodeapi().
 */
function metrics_nodeapi(&$node, $op, $teaser) {
  switch ($op) {
    case 'load':
      if ($result = db_query('SELECT mp.property_id, mp.name, mpr.value, mpr.description FROM {metrics_property} mp INNER JOIN {metrics_property_result} mpr ON mp.property_id = mpr.property_id WHERE mpr.nid = %d', $node->nid)) {
        $output = array();
        while ($o = db_fetch_array($result)) {
          $output['metrics'][$o['property_id']] = $o;
        }
        return $output;
      }
      break;

    case 'insert':
    case 'update':
      // Mark all of our results as stale so they'll be re-computed.
      db_query("UPDATE {metrics_property_result} SET timestamp = 0 WHERE nid = %d", $node->nid);
      break;

    case 'delete':
      db_query('DELETE FROM {metrics_property_result} WHERE nid = %d', $node->nid);
      break;
  }
}


/**
 * Return an array of all metric objects.
 *
 * TODO: this should take node type as a parameter.
 */
function metrics_get_properties() {
  $properties = array();

  // Ensure that the .inc files are loaded.
  _metrics_get_metrics_functions();

  $result = db_query('SELECT * FROM {metrics_property} mp ORDER BY mp.name');
  while ($property = db_fetch_array($result)) {
    $property['node_types'] = array();
    $sub_result = db_query('SELECT type FROM {metrics_property_node_types} mpnt WHERE property_id = %d', $property['property_id']);
    while ($type = db_fetch_object($sub_result)) {
      $property['node_types'][$type->type] = $type->type;
    }

    $property['metrics'] = array();
    $sub_result = db_query('SELECT metric_id, function_name, options, displayed, multiplier FROM {metrics_metric} mm WHERE property_id = %d ORDER BY function_name', $property['property_id']);
    while ($metric = db_fetch_array($sub_result)) {
      if (isset($metric['options']) && $options = unserialize($metric['options'])) {
        $metric['options'] = $options;
      }
      else {
        $metric['options'] = array();
      }
      $property['metrics'][$metric['metric_id']] = $metric;
    }

    $property['rankings'] = array();
    $sub_result = db_query('SELECT ranking_id, name, threshold, description FROM {metrics_ranking} mr WHERE property_id = %d ORDER BY threshold DESC', $property['property_id']);
    while ($ranking = db_fetch_array($sub_result)) {
      $property['rankings'][$ranking['ranking_id']] = $ranking;
    }

    $properties[$property['property_id']] = $property;
  }

  return $properties;
}

/**
 * Return the property with a given ID.
 *
 * @param $property_id
 *   The metric's ID
 *
 * @return Object
 *   The metric object with all of its metadata.
 *   Results are statically cached.
 */
function metrics_get_property($property_id) {
  static $properties = array();

  if (!array_key_exists($property_id, $properties)) {
    $properties = metrics_get_properties();
  }

  return $properties[$property_id];
}

/**
 * Recompute the 
 *
 * @param $property_id
 *   Integer property ID.
 * @param $node
 *   Node object.
 * @return
 *   The numeric result of the property, or FALSE on error.
 */
function metrics_compute_property($property_id, $node) {
  if ($property = metrics_get_property($property_id)) {
    // Go ahead and delete first because if we can't compute it there shouldn't
    // be a row in the database for it.
    db_query('DELETE FROM {metrics_property_result} WHERE property_id = %d AND nid = %d', $property_id, $node->nid);

    if (isset($property['node_types'][$node->type])) {
      $total = 0.0;
      $description = '';
      foreach ($property['metrics'] as $metric_id => $metric) {
        if ($result = metrics_call_metric($metric, 'compute', $node)) {
          // Add up the numeric part.
          $total += $result['value'] * $metric['multiplier'];
          // If the metric is displayed include the string part.
          $description .= $metric['displayed'] ? ($result['description'] . ' ') : '';
        }
      }
      
      // Determine which ranking this value falls into. We assume that 
      // metrics_get_property() returns the rankings sorted by descending 
      // threshold value.
      $last_ranking_id = NULL;
      foreach ($property['rankings'] as $ranking_id => $ranking) {
        if ($ranking['threshold'] < $total) {
          break;
        }
      }

      db_query("INSERT INTO {metrics_property_result} (property_id, nid, ranking_id, value, description, timestamp) VALUES (%d, %d, %d, %d, '%s', %d)", $property_id, $node->nid, $ranking_id, $total, $description, time());
#      drupal_set_message(t("%property metrics was computed for %node (@score): @description", array('%property' => $property['name'], '%node' => $node->title, '@score' => $total, '@description' => $description)));
      return $total;
    }
  }
  return FALSE;
}

/**
 * Return an array of the metrics computation functions.
 *
 * @param $refresh
 *   Boolean indicating if the list should be fully recomputed.
 * @return
 *   An array of function names.
 */
function _metrics_get_metrics_functions($refresh = FALSE) {
  static $_functions;

  if ($refresh || !isset($_functions)) {
    $_functions = array();

    // Load our .inc files that provide metrics for other projects.
    $path = drupal_get_path('module', 'metrics') .'/modules';
    $files = drupal_system_listing('.inc$', $path, 'name', 0);
    foreach ($files as $file) {
      // Only load the file if a module of that same name exists.
      if (module_exists($file->name)) { 
        require_once('./' . $file->filename);
        $function = 'metrics_'. $file->name . '_metrics_functions';
        $result = $function();
        if (isset($result) && is_array($result)) {
          $_functions = array_merge($_functions, $result);
        }
      }
    }

    // Invoke the hook and return the results.
    $_functions = array_merge($_functions, module_invoke_all('metrics_functions'));
    
    // Only store functions that exist. 
    $_functions = array_filter($_functions, 'function_exists');
  }

  return $_functions;
}

/**
 * Helper function to call metrics. This is used rather than 
 * $metric['function_name']() because it makes it easier to locate calls in 
 * code.
 *
 * @param $metric
 *   Metric array.
 * @param $op
 *   String indicating the operation to call. Possible values are:
 *   - 'info' returns an array with a name and description.
 *   - 'compute' returns an array with a numeric and string value.
 *   - 'options' returns an array of form elements defining the metric's 
 *     options.
 * @return
 *   Mixed depending on the $op or FALSE if the function doesn't exist.
 */
function metrics_call_metric($metric, $op, $node = NULL) {
  if (function_exists($metric['function_name'])) {
    return $metric['function_name']($op, $metric['options'], $node);
  }
  return FALSE;
}

/**
 * Module settings form.
 */
function metrics_settings_form() {
  $times = array(6048000, 5443200, 4838400, 4233600, 3628800, 3024000, 2419200, 1814400, 1209600, 604800, 518400, 432000, 345600, 259200, 172800, 86400);
  $ageoptions = drupal_map_assoc($times, 'format_interval');
  $form['metrics_recompute_after'] = array(
    '#type' => 'select',
    '#title' => t('Update after'),
    '#default_value' => variable_get('metrics_recompute_after', 604800),
    '#options' => $ageoptions,
    '#description' => t("Once the metrics are older than this, they will be updated during a cron run."),
  );

  $limit = drupal_map_assoc(array(5, 10, 15, 20, 25, 50, 100, 200, 300, 500));
  $form['metrics_cron_limit'] = array(
    '#type' => 'select',
    '#title' => t('Cron limit'),
    '#default_value' => variable_get('metrics_cron_limit', 50),
    '#options' => $limit,
    '#description' => t("The number of nodes to recompute each cron run."),
  );

  return system_settings_form($form);
}


/**
 * Project metrics overview settings, display a list of metrics.
 */
function metrics_admin_overview() {
  $properties = metrics_get_properties();
  $node_types = node_get_types('names');

  $rows = array();
  foreach ($properties as $property_id => $property) {
    $types = array();
    foreach ($property['node_types'] as $type) {
      if (isset($node_types[$type])) {
        $types[] = $node_types[$type];
      }
    }
    $rows[] = array(
      'name' => l(check_plain($property['name']), "admin/content/metrics/$property_id"),
      'type' => implode(', ', $types),
      'edit' => l(t('edit metric'), "admin/content/metrics/$property_id/edit"),
    );
  }
  if (empty($rows)) {
    $rows[] = array(array('data' => t('No Properties exist.'), 'colspan' => '3'));
  }
  $header = array(t('Name'), t('Type'), t('Operations'));

  return theme('table', $header, $rows);
}


function metrics_property_overview($property_id) {
  $property = metrics_get_property($property_id);
  if (!$property) {
    return drupal_not_found();
  }

  drupal_set_title($property['name']);

  $content['name'] = array(
    '#type' => 'item',
    '#title' => t('Property name'),
    '#value' => check_plain($property['name']),
  );
  $content['description'] = array(
    '#type' => 'item',
    '#title' => t('Description'),
    '#value' => check_plain($property['description']),
  );
  $types = array();
  $node_types = node_get_types('names');
  foreach ($property['node_types'] as $type) {
    if (isset($node_types[$type])) {
      $types[] = $node_types[$type];
    }
  }
  $content['node_types'] = array(
    '#type' => 'item',
    '#title' => t('Node types'),
    '#value' => check_plain(implode(', ', $types)),
  );
  
  $rows = array();
  foreach ((array) $property['metrics'] as $metric_id => $metric) {
    $info = metrics_call_metric($metric, 'info');
    $rows[] = array(
      $info['name'], 
      $metric['multiplier'], 
      $metric['displayed'] ? t('Yes') : '',
    );
  }
  if (!$rows) {
    $rows[][] = array('data' => t('No metrics found.'), 'colspan' => 3);
  }
  $header = array(t('Name'), t('Multiplier'), t('Displayed'));
  $content['metrics'] = array(
    '#type' => 'item',
    '#title' => t('Metrics'),
    '#value' => theme('table', $header, $rows),
    '#weight' => 5,
  );
  
  $rows = array();
  foreach ((array) $property['rankings'] as $ranking_id => $ranking) {
    $rows[] = array(
      $ranking['name'], 
      $ranking['threshold'], 
      $ranking['description'],
    );
  }
  if (!$rows) {
    $rows[][] = array('data' => t('No rankings found.'), 'colspan' => 4);
  }
  $header = array(t('Name'), t('Threshold'), t('Description'));
  $content['rankings'] = array(
    '#type' => 'item',
    '#title' => t('Rankings'),
    '#value' => theme('table', $header, $rows),
    '#weight' => 6,
  );

  return drupal_render($content);
}

function metrics_property_edit($property_id = NULL) {
  if ($_POST['op'] == t('Delete') || $_POST['confirm']) {
    drupal_goto('admin/content/metrics/'. $property_id .'/delete');
  }
  if ($property = metrics_get_property($property_id)) {
    return drupal_get_form('metrics_property_form', $property);
  }
  return drupal_not_found();
}

/**
 * Property edit form.
 */
function metrics_property_form($edit = array()) {
  if (isset($edit['name'])) {
    drupal_set_title(check_plain($edit['name']));
  }

  $form['name'] = array(
    '#type' => 'textfield',
    '#title' => t('Property name'),
    '#default_value' => $edit['name'],
    '#maxlength' => 255,
    '#required' => TRUE,
  );
  $form['description'] = array(
    '#type' => 'textarea',
    '#title' => t('Description'),
    '#default_value' => $edit['description'],
  );
  $form['node'] = array(
    '#type' => 'fieldset',
    '#title' => t('Node types'),
    '#collapsible' => TRUE,
    '#collapsed' => FALSE,
    '#description' => t('The property will be measured for these node types.'),
  );
  $form['node']['node_types'] = array(
    '#type' => 'checkboxes',
    '#options' => node_get_types('names'),
    '#default_value' => $edit['node_types'],
  );

  $form['submit'] = array('#type' => 'submit', '#value' => t('Submit'));
  if ($edit['property_id']) {
    $form['delete'] = array('#type' => 'submit', '#value' => t('Delete'));
    $form['property_id'] = array('#type' => 'value', '#value' => $edit['property_id']);
  }
  return $form;
}


function metrics_property_form_submit($form_id, $form_values) {
  if (!empty($form_values['property_id'])) {
    db_query("UPDATE {metrics_property} SET name = '%s', description = '%s' WHERE property_id = %d", $form_values['name'], $form_values['description'], $form_values['property_id']);
    
    // Figure out which node types have been added and removed.
    $new_types = array_keys(array_filter($form_values['node_types']));
    $old_types = array();
    $result = db_query('SELECT type FROM {metrics_property_node_types} mpnt WHERE property_id = %d', $form_values['property_id']);
    while ($o = db_fetch_object($result)) {
      $old_types[] = $o->type;
    }
    // Removals.
    foreach (array_diff($old_types, $new_types) as $type) {
      // When removing node type we should remove any {metrics_property_result} records for nodes of that type.
      db_query("DELETE FROM {metrics_property_result} WHERE property_id = %d AND nid IN (SELECT nid FROM {node} n WHERE n.type = '%s')", $form_values['property_id'], $type);
      db_query("DELETE FROM {metrics_property_node_types} WHERE property_id = %d AND type = '%s'", $form_values['property_id'], $type);
    }
    // Additions.
    foreach (array_diff($new_types, $old_types) as $type) {
      db_query("INSERT INTO {metrics_property_node_types} (property_id, type) VALUES (%d, '%s')", $form_values['property_id'], $type);
    }
  }
  else {
    $form_values['property_id'] = db_next_id('{metrics_property}_property_id');
    db_query("INSERT INTO {metrics_property} (property_id, name, description) VALUES (%d, '%s', '%s')", $form_values['property_id'], $form_values['name'], $form_values['description']);
    foreach (array_filter($form_values['node_types']) as $type => $selected) {
      db_query("INSERT INTO {metrics_property_node_types} (property_id, type) VALUES (%d, '%s')", $form_values['property_id'], $type);
    }
  }
  return 'admin/content/metrics/'. $form_values['property_id'];
}

function metrics_metric_delete_form($property_id) {
  $property = metrics_get_property($property_id);

  $form['property_id'] = array('#type' => 'value', '#value' => $property_id);
  $form['name'] = array('#type' => 'value', '#value' => $property['name']);
  return confirm_form(
    $form,
    t('Are you sure you want to delete the property %title?', array('%title' => $property['name'])),
    'admin/content/metrics',
    t('Deleting a property will delete all the metrics, results and rankings associated with it. This action cannot be undone.'),
    t('Delete'),
    t('Cancel')
  );
}

function metrics_metric_delete_form_submit($form_id, $form_values) {
  metrics_metric_delete($form_values['property_id']);

  drupal_set_message(t('Deleted metric %name.', array('%name' => $form_values['name'])));
  watchdog('metrics', t('Deleted metric %name.', array('%name' => $form_values['name'])), WATCHDOG_NOTICE);
  return 'admin/content/metrics';
}

/**
 * Delete a metric.
 *
 * @param $property_id
 *   The metric's ID.
 */
function metrics_metric_delete($property_id) {
  db_query('DELETE FROM {metrics_property} WHERE property_id = %d', $property_id);
  db_query('DELETE FROM {metrics_property_node_types} WHERE property_id = %d', $property_id);
  db_query('DELETE FROM {metrics_property_result} WHERE property_id = %d', $property_id);
  db_query('DELETE FROM {metrics_metric} WHERE property_id = %d', $property_id);
  db_query('DELETE FROM {metrics_ranking} WHERE property_id = %d', $property_id);
}


/**
 * Property metrics form.
 */
function metrics_metrics_form($edit = array()) {
  if (isset($edit['name'])) {
    drupal_set_title(check_plain($edit['name']));
  }

  $function_options = array(0 => '<Select One>');
  foreach (_metrics_get_metrics_functions() as $function) {
    $info = $function('info');
    $function_options[$function] = $info['name'];
  }

  $form['property_id'] = array(
    '#type' => 'value',
    '#value' => $edit['property_id'],
  );
  $form['metrics'] = array(
    '#tree' => TRUE,
  );
  foreach ((array) $edit['metrics'] as $key => $metric) {
    $form['metrics'][$key]['delete'] = array(
      '#type' => 'checkbox',
    );

    if ($info = metrics_call_metric($metric, 'info')) {
      $form['metrics'][$key]['function_name'] = array(
        '#type' => 'item',
        '#value' => $info['name'],
        '#description' => $info['description'],
      );
    }
    else {
     $form['metrics'][$key]['function_name'] = array(
        '#type' => 'item',
        '#value' => t('Missing function: %name', array('%name' => $metric['function_name'])),
      );
    }

    $form['metrics'][$key]['multiplier'] = array(
      '#type' => 'textfield',
      '#default_value' => $metric['multiplier'],
      '#size' => 10,
      '#required' => TRUE,
    );
    $form['metrics'][$key]['displayed'] = array(
      '#type' => 'checkbox',
      '#default_value' => $metric['displayed'],
    );
    // Allow the metric to put options on to the form.
    $form['metrics'][$key]['options'] = metrics_call_metric($metric, 'options');
  }

  // If there's nothing in the select other than <Select One> then don't bother
  // letting them add a new function.
  if (count($function_options) > 1) {
    $form['metrics']['new']['function_name'] = array(
      '#type' => 'select',
      '#options' => $function_options,
    );
    $form['metrics']['new']['multiplier'] = array(
      '#type' => 'textfield',
      '#default_value' => '1.0',
      '#size' => 10,
      '#required' => TRUE,
    );
    $form['metrics']['new']['displayed'] = array(
      '#type' => 'checkbox',
      '#default_value' => TRUE,
    );
  }

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

function theme_metrics_metrics_form(&$form) {
  $header = array(t('Delete'), t('Function'), t('Multiplier'), t('Displayed'), t('Options'));
  foreach (element_children($form['metrics']) as $key) {
    $row = array();
    $row[] = drupal_render($form['metrics'][$key]['delete']);
    $row[] = drupal_render($form['metrics'][$key]['function_name']);
    $row[] = drupal_render($form['metrics'][$key]['multiplier']);
    $row[] = drupal_render($form['metrics'][$key]['displayed']);
    $row[] = drupal_render($form['metrics'][$key]['options']);
    $rows[] = $row;
  }
  $output .= theme('table', $header, $rows);
  $output .= drupal_render($form);

  return $output;
}

function metrics_metrics_form_submit($form_id, $form_values) {
  if (empty($form_values['property_id'])) {
    return;
  }

  $recompute = FALSE;

  // Add the metrics.
  foreach ($form_values['metrics'] as $metric_id => $metric) {
    if ($metric_id == 'new') {
      if (!empty($metric['function_name'])) {
        $metric_id = db_next_id('{metrics_metric}_metric_id');
        db_query("INSERT INTO {metrics_metric} (metric_id, property_id, function_name, options, displayed, multiplier) VALUES (%d, %d, '%s', '%s', %d, %f)", $metric_id, $form_values['property_id'], $metric['function_name'], serialize(array()), $metric['displayed'], $metric['multiplier']);
        $recompute = TRUE;
      }
    }
    else if ($metric['delete']) {
      db_query("DELETE FROM {metrics_metric} WHERE metric_id = %d", $metric_id);
      $recompute = TRUE;
    }
    else {
      db_query("UPDATE {metrics_metric} SET displayed = %d, options = '%s', multiplier = %f WHERE metric_id = %d", $metric['displayed'], serialize($metric['options']), $metric['multiplier'], $metric_id);
      $recompute = TRUE;
    }
  }  
  
  if ($recompute) {
    // Mark all these results as stale so they're recomputed.
    db_query("UPDATE {metrics_property_result} SET timestamp = 0 WHERE property_id = %d", $form_values['property_id']);
    drupal_set_message(t('On the next cron run @count rows will need to be re-computed.', array('@count' => db_affected_rows())));
  }
}


/**
 * Property ranking form.
 */
function metrics_rankings_form($edit = array()) {
  if (isset($edit['name'])) {
    drupal_set_title(check_plain($edit['name']));
  }

  $form['property_id'] = array(
    '#type' => 'value',
    '#value' => $edit['property_id'],
  );
  $form['rankings']['#tree'] = TRUE;
  foreach ((array) $edit['rankings'] as $ranking_id => $ranking) {
    $form['rankings'][$ranking_id]['delete'] = array(
      '#type' => 'checkbox',
    );
    $form['rankings'][$ranking_id]['name'] = array(
      '#type' => 'textfield',
      '#default_value' => $ranking['name'],
      '#size' => 15,
      '#required' => TRUE,
    );
    $form['rankings'][$ranking_id]['threshold'] = array(
      '#type' => 'textfield',
      '#default_value' => $ranking['threshold'],
      '#size' => 5,
      '#required' => TRUE,
    );
    $form['rankings'][$ranking_id]['description'] = array(
      '#type' => 'textfield',
      '#default_value' => $ranking['description'],
      '#size' => 20,
    );
  }

  $form['rankings']['new']['name'] = array(
    '#type' => 'textfield',
    '#size' => 15,
  );
  $form['rankings']['new']['threshold'] = array(
    '#type' => 'textfield',
    '#size' => 5,
  );
  $form['rankings']['new']['description'] = array(
    '#type' => 'textfield',
    '#size' => 20,
  );

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

function theme_metrics_rankings_form(&$form) {
  $header = array(t('Remove'), t('Name'), t('Threshold'), t('Description'));
  foreach (element_children($form['rankings']) as $key) {
    $row = array();
    $row[] = drupal_render($form['rankings'][$key]['delete']);
    $row[] = drupal_render($form['rankings'][$key]['name']);
    $row[] = drupal_render($form['rankings'][$key]['threshold']);
    $row[] = drupal_render($form['rankings'][$key]['description']);
    $rows[] = $row;
  }
  $output .= theme('table', $header, $rows);
  $output .= drupal_render($form);

  return $output;
}

function metrics_rankings_form_submit($form_id, $form_values) {
  if (empty($form_values['property_id'])) {
    return;
  }

  $recompute = FALSE;

  // Add the rankings.
  foreach ($form_values['rankings'] as $ranking_id => $ranking) {
    if ($ranking_id == 'new') {
      if (!empty($ranking['name'])) {
        $ranking_id = db_next_id('{metrics_ranking}_ranking_id');
        db_query("INSERT INTO {metrics_ranking} (ranking_id, property_id, name, threshold, description) VALUES (%d, %d, '%s', %d, '%s')", $ranking_id, $form_values['property_id'], $ranking['name'], $ranking['threshold'], $ranking['description']);
        $recompute = TRUE;
      }
    }
    else if ($ranking['delete']) {
      db_query("DELETE FROM {metrics_ranking} WHERE ranking_id = %d", $ranking_id);
      $recompute = TRUE;
    }
    else {
      db_query("UPDATE {metrics_ranking} SET name = '%s', threshold = %d, description = '%s' WHERE ranking_id = %d", $ranking['name'], $ranking['threshold'], $ranking['description'], $ranking_id);
      $recompute = TRUE;
    }
  }
  
  if ($recompute) {
    // Mark all these results as stale so they're recomputed.
    db_query("UPDATE {metrics_property_result} SET timestamp = 0 WHERE property_id = %d", $form_values['property_id']);
    drupal_set_message(t('On the next cron run @count rows will need to be re-computed.', array('@count' => db_affected_rows())));    
  }
}


function metrics_metrics_functions() {
  return array(
    '_metrics_body_word_count',
  );
}


function _metrics_body_word_count($op, $options = NULL, $node = NULL) {
  switch ($op) {
    case 'info':
      return array(
        'name' => t('Metrics: Node body length'),
        'description' => t('If there are more than the specified number of words, returns 1.'),
      );

    case 'compute':
      $wc = explode(' ', $node->body);
      if ($wc > $options['words']) {
        return array(
          'value' => 1, 
          'description' => t('The node body is longer than @count words.', array('@count' => $options['words'])),
        );
      }
      else {
        return array(
          'value' => 0, 
          'description' => t('The node description is too short.', array('@count' => $options['words'])),
        );
      }

    case 'options':
      $limit = drupal_map_assoc(array(5, 10, 15, 20, 25, 50, 100, 200, 300, 500));
      $form['words'] = array(
        '#type' => 'select',
        '#title' => t('Word count'),
        '#default_value' => isset($options['words']) ? $options['words'] : 100,
        '#options' => $limit,
      );
      return $form;
  }
}