Club Drupal

files[] = captcha.install

files[] = captcha.test

core = "7.x"

project = "captcha"

      'sid' => array(

        'description' => "Session ID of the user.",

        'type' => 'varchar',

        'not null' => TRUE,

        'default' => '',

      ),

      ->execute();

  }

}

files[] = image_captcha.user.inc

files[] = image_captcha.test

core = "7.x"

project = "captcha"

  var options = e.data;

  // Ensure that the iFrame is defined.

    return;

  }

package = Media

core = 7.x

dependencies[] = image

dependencies[] = views

; We have to add a fake version so Git checkouts do not fail Media dependencies

version = 7.x-2.x-dev

core = "7.x"

project = "media"

  if ($phase == 'update') {

    $info = system_get_info('module', 'file_entity');

      $requirements['file_entity'] = array(

        'value' => $t('Wrong version'),

        'severity' => REQUIREMENT_ERROR,

      );

    }

  }

        $requirements['entity_translation']['severity'] = REQUIREMENT_ERROR;

        $requirements['entity_translation']['value'] = $et_installed_version;

        $requirements['entity_translation']['title'] = $t('Entity translation (when installed) with Media');

      }

    }

  }

files[] = includes/MediaBrowserBulkUpload.inc

files[] = tests/media_bulk_upload.test

core = "7.x"

project = "media"

files[] = includes/MediaInternetValidationException.inc

files[] = tests/media_internet.test

core = "7.x"

project = "media"

files[] = includes/MediaInternetTestStreamWrapper.inc

files[] = includes/MediaInternetTestHandler.inc

core = "7.x"

project = "media"

configure = admin/structure/file-types/upgrade

core = "7.x"

project = "media"

  margin-left: 20px;

}

.media-wysiwyg-align-center {

  text-align: center;

}

            $settings[$dimension] = $settings['attributes'][$dimension];

          }

        }

      }

      foreach (array('title', 'alt') as $field_type) {

        if (isset($settings['attributes'][$field_type])) {

      field_attach_prepare_view('file', array($file->fid => $file), $tag_info['view_mode'], $langcode);

      entity_prepare_view('file', array($file->fid => $file), $langcode);

      $element['content'] += field_attach_view('file', $file, $tag_info['view_mode'], $langcode);

    }

    if (count(element_children($element['content'])) > 1) {

      // Add surrounding divs to group them together.

        'media-element-container',

        'media-' . $element['content']['file']['#view_mode'],

      );

      if (variable_get('media_wysiwyg_remove_media_class', FALSE)) {

        $classes = $element['content']['#attributes']['class'];

        $element['content']['#attributes']['class'] = array_diff($classes, array('media'));

 */

Drupal.wysiwyg.plugins.media = {

  /**

   * Determine whether a DOM element belongs to this plugin.

   *

        insert.onSelect([media_file]);

      }

      else {

        // Insert new media.

        insert.prompt(settings.global);

      }

          fid: this.mediaFile.fid,

          view_mode: formatted_media.type,

          attributes: this.mediaFile.attributes,

        });

    // Get the markup and register it for the macro / placeholder handling.

    var markup = Drupal.media.filter.getWysiwygHTML(element);

configure = admin/config/media/browser

core = "7.x"

project = "media"

    // Ensure that the alt/title from attributes display rather the field ones.

    $this->assertRaw(drupal_attributes($attributes), t('Image displays with alt/title set as attributes overriding field values.'));

  }

}

package = Media

core = 7.x

core = "7.x"

project = "media"

core = 7.x

dependencies[] = media

core = "7.x"

project = "media"

files[] = includes/MediaModuleTest.inc

core = "7.x"

project = "media"

/**

 * @file

 */

/**

 */

function webform_validation_manage($node) {

  $rules = webform_validation_get_webform_rules($node);

}

/**

 */

function webform_validation_get_webform_rules($node) {

  if (in_array($node->type, webform_variable_get('webform_node_types'))) {

  return $rules;

}

/**

 */

function theme_webform_validation_manage_overview_form($variables) {

  $form = $variables['form'];

  $rows = array();

  foreach (element_children($form) as $rule) {

    $row = array();

    foreach (element_children($form[$rule]) as $item) {

      unset($form[$rule][$item]['#title']);

      $form[$rule]['weight']['#attributes']['class'] = array('ruleid-weight');

      $row[] = array(

        'data' => drupal_render($form[$rule][$item]),

      'colspan' => 5,

    );

  }

  $output .= drupal_render_children($form);

  if ($drag) {

    drupal_add_tabledrag('webform-validation-overview-form', 'order', 'sibling', 'ruleid-weight');

}

/**

 */

function webform_validation_manage_overview_form($form, &$form_state, $rules, $node) {

  $form = array();

 * Submit function for rule overview form.

 */

function webform_validation_manage_overview_form_submit($form, $form_state) {

  foreach ($form_state['values'] as $ruleid => $value) {

    if (is_numeric($ruleid)) {

      $update = db_update('webform_validation_rule')

    }

  }

  drupal_set_message(t('The order of the validation rules has been saved.'));

}

/**

 */

  $form = array();

  $rule_validator = webform_validation_get_validator_info($validator);

}

/**

 */

function webform_validation_manage_rule_validate($form, &$form_state) {

  $values = $form_state['values'];

  $selected_components = count(array_filter($values['rule_components']));

  // Check validator min_components and min_components property when they are equal.

  if (isset($rule_validator['min_components']) && isset($rule_validator['max_components']) && $rule_validator['min_components'] === $rule_validator['max_components'] && $selected_components !== $rule_validator['min_components']) {

  }

  elseif (isset($rule_validator['min_components']) && $selected_components < $rule_validator['min_components']) {

  }

  elseif (isset($rule_validator['max_components']) && $selected_components > $rule_validator['max_components']) {

  }

}

/**

 */

function webform_validation_manage_rule_submit($form, &$form_state) {

  $values = $form_state['values'];

}

/**

 */

function webform_validation_get_webform_components($node, $validator) {

  $ret = array();

  $components = $node->webform['components'];

  if ($components) {

}

/**

 */

function webform_validation_delete_rule($form, &$form_state, $rule) {

  if (isset($rule['ruleid'])) {

    );

  }

  );

}

/**

 */

function webform_validation_delete_rule_submit($form, &$form_state) {

  $ruleid = $form_state['values']['ruleid'];

core = 7.x

package = Webform

dependencies[] = webform

php = 5.3

core = "7.x"

project = "webform_validation"

/**

 * @file

 */

/**

}

/**

 */

function _webform_validation_update_range_syntax($range) {

  if ($range === "0") {

    return "";

  }

  if (preg_match('/^0 ?-/', $range)) {

    $range_arr = explode('-', $range);

    $range_end = $range_arr[1];

    return "|" . trim($range_end);

  }

  $range = str_replace("-", "|", $range);

  return $range;

}

/**

 * @file

 */

/**

 * Implements hook_menu().

}

/**

 */

function webform_validation_rule_load($ruleid) {

  return webform_validation_get_rule($ruleid);

}

/**

 * Implements hook_theme().

 */

  $groups['webform_validation'] = array(

    'title' => t('Webform Validation'),

    'description' => t('Translatable strings for webform validation translation'),

    'refresh callback' => 'webform_validation_i18n_string_refresh',

  );

  return $groups;

}

/**

 */

function webform_validation_validate($form, &$form_state) {

  $static_error_messages = &drupal_static(__FUNCTION__, array());

  $rules = webform_validation_get_node_rules($nid);

  $sid = empty($form_state['values']['details']['sid']) ? 0 : $form_state['values']['details']['sid'];

  if (isset($form_state['webform']['page_count'])) {

    $page_count = $form_state['webform']['page_count'];

  }

    $page_count = $form_state['storage']['page_count'];

  }

  if ($values && $page_count && $page_count > 1) {

          }

        }

      }

    }

  }

    }

    else {

      // Old conditionals system removed in Webform 7.x-4.8.

      if (!defined('WEBFORM_CONDITIONAL_INCLUDE')) {

        define('WEBFORM_CONDITIONAL_INCLUDE', 1);

      }

      foreach ($component_definitions as $key => $component) {

        // Cast to int so that the function behaves as it does in 7.x-4.x.

        if (isset($flat_values[$key]) && (int) _webform_client_form_rule_check($node, $component, 0, $form_state['values']['submitted']) !== WEBFORM_CONDITIONAL_INCLUDE) {

          unset($flat_values[$key]);

    }

    foreach ($rules as $rule) {

      $items = array();

      foreach ($rule['components'] as $cid => $component) {

        if (array_key_exists($cid, $flat_values)) {

          $items[$cid] = $flat_values[$cid];

        }

      }

      $items = webform_validation_prefix_keys($items);

      $rule['sid'] = $sid;

      $errors = module_invoke_all("webform_validation_validate", $rule['validator'], $items, $component_definitions, $rule);

      if ($errors) {

        $errors = webform_validation_unprefix_keys($errors);

        $components = webform_validation_unprefix_keys($component_definitions);

        foreach ($errors as $item_key => $error) {

          if (in_array($error, $static_error_messages, TRUE)) {

            continue;

          }

          $static_error_messages[] = $error;

          $error_key = 'submitted][' . webform_validation_parent_tree($item_key, $components) . $components[$item_key]['form_key'];

          if (is_array($error)) {

            foreach ($error as $sub_item_key => $sub_error) {

            }

          }

          else {

            form_set_error($error_key, $error);

          }

        }

}

/**

 */

function webform_validation_get_field_keys($submitted, $node) {

  static $fields = array();

  foreach (element_children($submitted) as $child) {

    if (is_array($submitted[$child]) && element_children($submitted[$child])) {

      $group_components = _webform_validation_get_group_types();

      if (in_array(_webform_validation_get_component_type($node, $child), $group_components)) {

        webform_validation_get_field_keys($submitted[$child], $node);

}

/**

 */

function webform_validation_parent_tree($cid, $components) {

  $output = '';

}

/**

 */

function webform_validation_rule_get_formkeys($rule) {

  $formkeys = array();

}

/**

 */

function webform_validation_prefix_keys($arr) {

  $ret = array();

}

/**

 */

function webform_validation_unprefix_keys($arr) {

  $ret = array();

  }

  return $ret;

}

/**

 */

function theme_webform_validation_manage_add_rule($variables) {

  $nid = $variables['nid'];

}

/**

 */

function webform_validation_node_clone($node) {

  if (!in_array($node->type, webform_variable_get('webform_node_types'))) {

  }

  if (isset($node->clone_from_original_nid)) {

    $original_nid = $node->clone_from_original_nid;

    $rules = webform_validation_get_node_rules($original_nid);

    if ($rules) {

      foreach ($rules as $orig_ruleid => $rule) {

        unset($rule['ruleid']);

        $rule['action'] = 'add';

        $rule['rule_components'] = $rule['components'];

        webform_validation_rule_save($rule);

      }

}

/**

 *

 * @param array $values

 *   An associative array containing:

 * @return int

 *   The $ruleid of the rule added or edited.

 */

  if ($values['action'] === 'add') {

    $primary_keys = array();

  }

 * @param int $ruleid

 *   The ruleid of the rule being saved.

 * @param array $components

 * @return array

 *   An array of the return statuses for each query keyed by cid.

 */

  $return_status = array();

  foreach ($components as $cid => $component) {

    $return_status[$cid] = db_merge('webform_validation_rule_components')

}

/**

 */

function _webform_validation_get_component_type($node, $component_key) {

  if ($node->webform['components']) {

}

/**

 */

function _webform_validation_get_group_types() {

  $types = array();

 * Implements hook_webform_validator_alter().

 */

function webform_validation_webform_validator_alter(&$validators) {

  if (module_exists('select_or_other')) {

    if ($validators) {

      foreach ($validators as $validator_name => $validator_info) {

        if (in_array('textfield', $validator_info['component_types'])) {

/**

 * @file

 */

/**

 */

function webform_validation_get_rule($ruleid) {

  $result = db_query("SELECT ruleid, rulename, nid, validator, data, error_message, negate, weight FROM {webform_validation_rule} WHERE ruleid = :ruleid", array(':ruleid' => $ruleid), array('fetch' => PDO::FETCH_ASSOC));

}

/**

 */

function webform_validation_get_node_rules($nid) {

  $rules = array();

}

/**

 */

function webform_validation_get_rule_components($ruleid, $nid) {

  $cids = array();

}

/**

 */

function webform_validation_get_all_components($nid) {

  $components = array();

/**

 * @file

 */

/**

 * - custom_data (optional): define whether custom data can be added to the validation rule

 * - min_components (optional): define the minimum number of components to be selected for creating a validation rule

 * - max_components (optional): define the maximum number of components to be selected for creating a validation rule

 */

function webform_validation_webform_validation_validators() {

  $validators = array(

      ),

      'custom_data' => array(

        'label' => t('Specify numeric validation range'),

        'required' => FALSE,

      ),

      'description' => t('Verifies that user-entered values are numeric, with the option to specify min and / or max values.'),

      ),

      'custom_data' => array(

        'label' => t('Number the fields add up to'),

      ),

      'description' => t('Require the values of the selected fields to add up to exactly, greater than or equal to, or less than or equal to a specified number.'),

    ),

        'label' => t('(Key) value'),

        'description' => t('Specify the specific value(s) you want the component to contain. Separate multiple options by a comma. For components that have keys, use the key value instead.'),

      ),

      'description' => t('Verifies that the value of the specified component is from a list of allowed values.'),

    ),

    'default_value' => array(

      ),

      'custom_data' => array(

        'label' => t('Number to be completed'),

      ),

      'min_components' => 2,

      'description' => t('Requires the user to complete some number of components out of a group of components. For example, complete at least 2 out of 3, complete at most 4 out of 6, or complete exactly 3 our of 4.'),

        'textarea',

        'textfield',

      ),

    ),

    'starts_with' => array(

      'name' => t('Starts with'),

      'custom_error' => TRUE,

      'custom_data' => array(

        'label' => t('Pattern'),

      ),

      'description' => t('Verifies that a user-entered value follows to a specified pattern.'),

    ),

        'label' => t('Blacklisted words'),

        'description' => t('Specify illegal words, seperated by commas.'),

      ),

    ),

    'username' => array(

      'name' => t('Must match a username'),

      $num_range = _webform_numeric_check_data($rule['data']);

      foreach ($items as $key => $val) {

        foreach ($val as $subval) {

          if (is_numeric($subval)) {

            $subval = (float) $subval;

          }

            continue;

          }

          if (isset($num_range['min']) && isset($num_range['max'])) {

            if ($subval < $num_range['min'] || $subval > $num_range['max']) {

            }

          }

          else {

            if (isset($num_range['min'])) {

              if ($subval < $num_range['min']) {

                $errors[$key] = t('%item should be greater than or equal to %val.', array('%item' => $components[$key]['name'], '%val' => $num_range['min']));

              }

            }

            if (isset($num_range['max'])) {

              if ($subval > $num_range['max']) {

                $errors[$key] = t('%item should be less than or equal to %val.', array('%item' => $components[$key]['name'], '%val' => $num_range['max']));

        }

      }

      return $errors;

    case 'min_length':

      $min_length = $rule['data'];

      foreach ($items as $key => $val) {

        }

      }

      return $errors;

    case 'max_length':

      $max_length = $rule['data'];

      foreach ($items as $key => $val) {

        }

      }

      return $errors;

    case 'min_words':

      $min_words = $rule['data'];

      foreach ($items as $key => $val) {

        }

      }

      return $errors;

    case 'max_words':

      $max_words = $rule['data'];

      foreach ($items as $key => $val) {

        }

      }

      return $errors;

    case 'sum':

      // Get the numbers to sum.

      $sum = array();

        $errors[$keys[0]] = t('These items must add up to %verb %compare_number:', array('%verb' => $error, '%compare_number' => $compare_number)) . theme('item_list', array('items' => _webform_validation_get_names_of_rule_components($rule)));

      }

      return $errors;

    case 'equal':

      $first_entry_key = key($items);

      $first_entry = array_shift($items);

        }

      }

      return $errors;

    case 'comparison':

      foreach (array(1, 2) as $count) {

        $entry[$count]['key'] = key($items);

            $error = TRUE;

          }

          break;

        case '>=':

          if (!($entry[1]['value'] >= $entry[2]['value'])) {

            $error = TRUE;

          }

          break;

        case '<':

          if (!($entry[1]['value'] < $entry[2]['value'])) {

            $error = TRUE;

          }

          break;

        case '<=':

          if (!($entry[1]['value'] <= $entry[2]['value'])) {

            $error = TRUE;

        $errors[$entry[2]['key']] = _webform_validation_i18n_error_message($rule);

      }

      return $errors;

    case 'unique':

      foreach ($items as $key => $val) {

        $items[$key] = _webform_validation_flatten_array($val);

      }

      $items_count = array_count_values(array_map('drupal_strtolower', array_map('trim', $items)));

      $doubles = array_filter($items_count, create_function('$x', 'return $x > 1;'));

      foreach ($items as $key => $val) {

        }

      }

      return $errors;

    case 'specific_value':

      $specific_values = explode(',', $rule['data']);

      $specific_values = array_map('trim', $specific_values);

        _webform_validation_test($errors, $key, $rule, $test);

      }

      return $errors;

    case 'default_value':

      foreach ($items as $key => $val) {

        $val = _webform_validation_flatten_array($val);

        _webform_validation_test($errors, $key, $rule, $test);

      }

      return $errors;

    case 'someofseveral':

      // Determine the number of components completed.

      foreach ($items as $key => $val) {

        $errors[$keys[0]] = t('You must complete %verb %compare_number of these items:', array('%verb' => $error, '%compare_number' => $compare_number)) . theme('item_list', array('items' => _webform_validation_get_names_of_rule_components($rule)));

      }

      return $errors;

    case 'select_min':

      $min_selections = $rule['data'];

      foreach ($items as $key => $val) {

        }

      }

      return $errors;

    case 'select_max':

      $max_selections = $rule['data'];

      foreach ($items as $key => $val) {

        }

      }

      return $errors;

    case 'select_exact':

      $allowed_selections = $rule['data'];

      foreach ($items as $key => $val) {

        _webform_validation_test($errors, $key, $rule, $test, $error_strings, $error_vars);

      }

      return $errors;

    case 'plain_text':

      foreach ($items as $key => $val) {

        $error_strings = array(

        }

      }

      return $errors;

    case 'starts_with':

    case 'ends_with':

      $pattern = preg_quote($rule['data'], '/');

        }

      }

      return $errors;

    case 'pattern':

      $pattern = preg_quote($rule['data'], '/');

      $pattern = str_replace('@', '[a-zA-Z]', $pattern);

        }

      }

      return $errors;

    case 'regex':

    case 'regexi':

      mb_regex_encoding('UTF-8');

        }

      }

      return $errors;

    case 'must_be_empty':

      foreach ($items as $key => $val) {

        if (count($val) !== 0) {

        }

      }

      return $errors;

    case 'blacklist':

      $blacklist = preg_quote($rule['data'], '/');

      $blacklist = explode(',', $blacklist);

        }

      }

      return $errors;

    case 'username':

      foreach ($items as $key => $val) {

        $error_strings = array(

        }

      }

      return $errors;

    case 'valid_url':

      foreach ($items as $key => $val) {

        $error_strings = array(

        }

      }

      return $errors;

    case 'email_verify':

      if (module_exists('email_verify')) {

        foreach ($items as $key => $val) {

/**

 * Return an array of the names of the components in a validation rule.

 *

 *   Array of information about a validation rule.

 *

 * @return array

}

/**

 */

function _webform_validation_flatten_array($val) {

  if (is_array($val)) {

}