Home » API reference » Drupal 5

patterns.module

Tracking 5.x-1.x branch
  1. drupal
    1. 5 contributions/patterns/patterns.module

Enables extremely simple adding/removing features to your site with minimal to no configuration

Functions & methods

NameDescription
patterns_disable_pattern
patterns_disable_pattern_submit
patterns_editMenu callback to edit a patterns data
patterns_edit_submitSubmit edits to the pattern
patterns_edit_validateValidate pattern modifications (make sure proper XML)
patterns_enable_pattern
patterns_enable_pattern_submit
patterns_execute_actionExecute an action
patterns_execute_pattern
patterns_executing
patterns_exit
patterns_form_alter
patterns_form_helper
patterns_from_sourceCreate a pattern from an XML data source
patterns_get_pattern
patterns_get_patterns
patterns_import_fileDisplay the import pattern file form
patterns_import_sourceDisplay the import pattern form
patterns_import_submit
patterns_import_urlDisplay the import pattern url form
patterns_import_validate
patterns_init
patterns_invoke
patterns_list
patterns_load
patterns_load_xml
patterns_menuImplementation of hook_menu().
patterns_modulesReturn a list of modules for a pattern
patterns_modules_pageList the modules used by a particular pattern
patterns_permImplementation of hook_perm().
patterns_process_modules
patterns_rearrange_data
patterns_revertMenu callback to undo a patterns update changes
patterns_save_pattern
patterns_token_valuesImplementation of hook_token_values()
theme_patterns_form_helper
theme_patterns_form_helper_menu
_patterns_check_file_dirCheck if a .htaccess file exists to prevent downloads of pattern files
_patterns_modify_valueFunction callback
_patterns_parse_tagRecurse through the values of a parsed xml file to create a multi-dimensional representation of the data.
_patterns_rearrange_data
_patterns_recurse_tokensRecurse an array and replace with tokens @ This is used instead of array_walk_recursive because of some strange issues with token_get_values failing.
_patterns_replace_tokensArray walk callback to replace tokens inside form values

File

View source
  1. <?php

  2. 

  3. /**

  4.  * @file

  5.  * Enables extremely simple adding/removing features to your site with minimal to no configuration

  6.  */

  7. 

  8. /**

  9.  * @todo:

  10.  * @ Enable pattern configurations

  11.  * @ **done**Enable actions to see ids created/updated from other actions inside the pattern (tokens?)

  12.  * @ **semi-done** Reset patterns

  13.  * @ Enable components to analyze the current pattern for better validation

  14.  * @ Allow module version restricting

  15.  * @ Put in functionality to auto-download modules (and the correct version)

  16.  * @ Enable backups before running patterns and reverting back to those backups

  17.  * @ Implement a progress meter

  18.  * @ Handle default values better to allow for absolute minimal actions

  19.  * @ Enable interactive actions by allowing patterns to resume from a saved position

  20.  * @ Implement an export feature for all available form_ids

  21.  * @ Allow resuming failed patterns

  22.  * @ In the pattern details, list any sub-patterns directly on the patterns listing page

  23.  */

  24. 

  25. /**

  26.  * Implementation of hook_perm().

  27.  */

  28. function patterns_perm() {

  29.   return array('administer patterns');

  30. } 

  31. 

  32. /**

  33.  * Implementation of hook_menu().

  34.  */ 

  35. function patterns_menu($may_cache) {

  36.   $items = array();

  37.   

  38.   if ($may_cache) {

  39.     $items[] = array('path' => 'admin/build/patterns',

  40.       'description' => t('Administer patterns available for your site'),

  41.       'access' => user_access('administer patterns'),  

  42.       'title' => t('Patterns'),

  43.       'callback' => 'patterns_list', 

  44.       'type' => MENU_NORMAL_ITEM

  45.     );

  46.     $items[] = array('path' => 'admin/build/patterns/list',

  47.       'title' => t('List'),

  48.       'callback' => 'patterns_list',

  49.       'type' => MENU_DEFAULT_LOCAL_TASK,

  50.       'weight' => -10

  51.     );

  52. //     $items[] = array('path' => 'admin/build/patterns/settings',

  53. //       'title' => t('Settings'),

  54. //       'callback' => 'drupal_get_form',

  55. //       'callback arguments' => array('patterns_settings'),

  56. //       'type' => MENU_LOCAL_TASK,

  57. //       'weight' => 10

  58. //     );    

  59.     $items[] = array('path' => 'admin/build/patterns/configure',

  60.       'title' => t('Configure Pattern'),

  61.       'callback' => 'drupal_get_form',

  62.       'callback arguments' => array('patterns_configure_pattern'),

  63.       'type' => MENU_CALLBACK

  64.     );

  65.     $items[] = array('path' => 'admin/build/patterns/edit',

  66.       'title' => t('Edit Pattern'),

  67.       'callback' => 'drupal_get_form',

  68.       'callback arguments' => array('patterns_edit'),

  69.       'type' => MENU_CALLBACK

  70.     );

  71. //     $items[] = array('path' => 'admin/build/patterns/info',

  72. //       'title' => t('Pattern Details'),

  73. //       'callback' => 'patterns_info',

  74. //       'type' => MENU_CALLBACK

  75. //     );    

  76.     $items[] = array('path' => 'admin/build/patterns/enable',

  77.       'access' => user_access('administer patterns'),

  78.       'title' => t('Enable Pattern'),

  79.       'callback' => 'drupal_get_form',

  80.       'callback arguments' => array('patterns_enable_pattern'),

  81.       'type' => MENU_CALLBACK

  82.     );

  83.     $items[] = array('path' => 'admin/build/patterns/disable',

  84.       'access' => user_access('administer patterns'),

  85.       'title' => t('Disable Pattern'),

  86.       'callback' => 'drupal_get_form',

  87.       'callback arguments' => array('patterns_disable_pattern'),

  88.       'type' => MENU_CALLBACK

  89.     );

  90.     $items[] = array('path' => 'admin/build/patterns/modules',

  91.       'access' => user_access('administer patterns'),

  92.       'title' => t('Pattern Modules'),

  93.       'callback' => 'patterns_modules_page',

  94.       'type' => MENU_CALLBACK

  95.     );

  96.     $items[] = array('path' => 'admin/build/patterns/revert',

  97.       'access' => user_access('administer patterns'),

  98.       'title' => t('Revert Pattern'),

  99.       'callback' => 'patterns_revert',

  100.       'type' => MENU_CALLBACK

  101.     );

  102.     $items[] = array('path' => 'admin/build/patterns/import',

  103.       'access' => user_access('administer patterns'),

  104.       'title' => t('Import'),

  105.       'callback' => 'drupal_get_form',

  106.       'callback arguments' => array('patterns_import_source'),

  107.       'type' => MENU_LOCAL_TASK

  108.     );

  109.     $items[] = array('path' => 'admin/build/patterns/import/xmltext',

  110.       'access' => user_access('administer patterns'),

  111.       'title' => t('Import via XML Source'),

  112.       'type' => MENU_DEFAULT_LOCAL_TASK

  113.     );

  114.     $items[] = array('path' => 'admin/build/patterns/import/xmlfile',

  115.       'access' => user_access('administer patterns'),

  116.       'title' => t('Import via XML File'),

  117.       'callback' => 'drupal_get_form',

  118.       'callback arguments' => array('patterns_import_file'),

  119.       'type' => MENU_LOCAL_TASK

  120.     );

  121.     $items[] = array('path' => 'admin/build/patterns/import/xmlurl',

  122.       'access' => user_access('administer patterns'),

  123.       'title' => t('Import via XML URL'),

  124.       'callback' => 'drupal_get_form',

  125.       'callback arguments' => array('patterns_import_url'),

  126.       'type' => MENU_LOCAL_TASK

  127.     );

  128. //     $items[] = array('path' => 'admin/build/patterns/import/server',

  129. //       'access' => user_access('administer patterns'),

  130. //       'title' => t('Import via Patterns Server'),

  131. //       'callback' => 'drupal_get_form',

  132. //       'callback arguments' => array('patterns_import_server'),

  133. //       'type' => MENU_LOCAL_TASK

  134. //     );

  135.   }

  136. 

  137.   return $items;

  138. }

  139. 

  140. /**

  141.  * Display the import pattern form

  142.  */

  143. function patterns_import_source() {

  144.   $form['xmlname'] = array(

  145.     '#type' => 'textfield',

  146.     '#title' => t('Pattern Identifier'),

  147.     '#description' => t('Machine readable name for the pattern. The actual title should be included in the pattern itself.'),

  148.     '#required' => true

  149.   );

  150.   $form['xmlsource'] = array(

  151.     '#type' => 'textarea',

  152.     '#rows' => 15,

  153.     '#title' => t('Enter Pattern XML'),

  154.     '#description' => t('Imported patterns are not executed until you run them manually. You can leave off the <?xml> tag at the top.')

  155.   );

  156.   $form['submit'] = array(

  157.     '#type' => 'submit',

  158.     '#value' => t('Submit')

  159.   );

  160.   $form['#base'] = 'patterns_import';

  161.   

  162.   return $form;

  163. }

  164. 

  165. /**

  166.  * Display the pattern settings form

  167.  */

  168. // function patterns_settings() {

  169. //   drupal_set_message('This feature not implemented yet.');

  170. // }

  171. 

  172. /**

  173.  * Display the import pattern from server form

  174.  */

  175. // function patterns_import_server() {

  176. //   drupal_set_message('This feature not implemented yet.');

  177. // }

  178. 

  179. /**

  180.  * Display the import pattern file form

  181.  */

  182. function patterns_import_file() {

  183.   $form['#attributes']['enctype'] = 'multipart/form-data';

  184.   $form['xmlfile'] = array(

  185.     '#type' => 'file',

  186.     '#title' => t('Upload XML Pattern File'),

  187.     '#description' => t('Imported patterns are not executed until you run them manually.'),

  188.     '#size' => 48

  189.   );

  190.   $form['submit'] = array(

  191.     '#type' => 'submit',

  192.     '#value' => t('Submit')

  193.   );

  194.   $form['#base'] = 'patterns_import';

  195.   

  196.   return $form;

  197. }

  198. 

  199. /**

  200.  * Display the import pattern url form

  201.  */

  202. function patterns_import_url() {

  203.   $form['xmlurl'] = array(

  204.     '#type' => 'textfield',

  205.     '#title' => t('Specify an XML url'),

  206.     '#description' => t('Import a pattern from a remote URL. Imported patterns are not executed until you run them manually.'),

  207.     '#size' => 48

  208.   );

  209.   $form['submit'] = array(

  210.     '#type' => 'submit',

  211.     '#value' => t('Submit')

  212.   );

  213.   $form['#base'] = 'patterns_import';

  214.   

  215.   return $form;

  216. }

  217. 

  218. function patterns_import_validate($form_id, $values) {

  219.   global $form_values;

  220. 

  221.   if ($file = file_check_upload('xmlfile')) {

  222.     $form_values['xmlsource'] = file_get_contents($file->filepath);

  223.   }

  224.   else if (isset($values['xmlfile'])) {

  225.     form_set_error('xmlfile', t('Error uploading XML file.'));

  226.   }

  227.   else if  ($values['xmlurl']) {

  228.     if (!ini_get('allow_url_fopen')) {

  229.       form_set_error('xmlsource', t('allow_url_fopen must be enabled in your php configuration in order to use this feature.'));

  230.       return;

  231.     }

  232. 

  233.     if (!($form_values['xmlsource'] = file_get_contents($values['xmlurl']))) {

  234.       form_set_error('xmlsource', t('Failed to retreive the pattern specified.'));

  235.       return;

  236.     }

  237.     

  238.     $form_values['xmlname'] = preg_replace('/\.[^\.]*$/', '', basename($form_values['xmlurl']));

  239.   }

  240. 

  241.   if (strpos($form_values['xmlsource'], '<?xml') !== 0) {

  242.     $form_values['xmlsource'] = '<?xml version="1.0" encoding="ISO-8859-1"?>' . $form_values['xmlsource'];

  243.   }

  244. 

  245.   if ($form_values['xmlname'] && preg_match('/[^a-zA-Z0-9_]/', $form_values['xmlname'])) {

  246.     form_set_error('xmlname', t('You can only include letters, numbers, and underscores in the pattern identifier.'));

  247.   }

  248.   else if ($form_values['xmlname'] && preg_match('/^_/', $form_values['xmlname'])) {

  249.     form_set_error('xmlname', t('You cannot start the pattern identifier with an underscore.'));

  250.   }

  251.   

  252.   

  253.   $parse = xml_parser_create();

  254.   xml_parse_into_struct($parse, $form_values['xmlsource'], $vals, $index);

  255.   

  256.   // Check that the xml was properly parsed and also that the

  257.   // root <pattern> tag and also an <info> tag were used.

  258.   if (!$vals || $vals[0]['tag'] != 'PATTERN' || $vals[1]['tag'] != 'INFO') {

  259.     form_set_error('xmlsource', t('Error parsing the XML, please check your syntax and try again.'));

  260.   }

  261. }

  262. 

  263. function patterns_import_submit($form_id, $form_values) {

  264.   if ($file = file_check_upload('xmlfile')) {

  265.     // Currently nothing is happening with files saved here....

  266.     if (file_check_directory(file_create_path(variable_get('patterns_save_xml', 'patterns')))) {

  267.       file_save_upload('xmlfile', variable_get('patterns_save_xml', 'patterns'));

  268.     }

  269.     else {

  270.       drupal_set_message(t('Pattern was registered but the file was not saved on the server because of improperly setup files directory.'));

  271.     }

  272.   }

  273.   else if ($form_values['xmlsource']) {

  274.     file_save_data($form_values['xmlsource'], variable_get('patterns_save_xml', 'patterns') .'/'. $form_values['xmlname'] .'.xml', FILE_EXISTS_REPLACE);

  275.   }

  276.   

  277.   // Reload patterns

  278.   patterns_get_patterns(true);

  279.   

  280.   return 'admin/build/patterns';

  281. }

  282. 

  283. function patterns_list() {

  284. 

  285.   drupal_add_css(drupal_get_path('module', 'patterns') .'/patterns.css');

  286.   drupal_add_js(drupal_get_path('module', 'patterns') .'/patterns.js');

  287. 

  288.   patterns_load();  

  289.   $patterns = patterns_get_patterns();

  290.   if (empty($patterns)) return t('No patterns available.');

  291.   

  292. //   $header = array(t('Title'), t('Status'), t('Version'), t('Public'), t('Actions'));

  293.   $header = array(t('Title'), t('Status'), t('Version'), t('Actions'));

  294. 

  295.   // List all patterns

  296.   $rows = array();

  297.   foreach($patterns as $pid => $pattern) {

  298.     $actions = array();   

  299.     if (!$pattern->status) {

  300.       $actions[] =  l(t('Run'), 'admin/build/patterns/enable/'. $pid);

  301.     }

  302.     else if ($pattern->enabled >= $pattern->updated) {

  303.       $actions[] =  l(t('Re-Run'), 'admin/build/patterns/enable/'. $pid);

  304.     }

  305.     else {

  306.       $actions[] = l(t('Run Update'), 'admin/build/patterns/enable/'. $pid);

  307.     }    

  308.     $actions[] = l(t('Edit'), 'admin/build/patterns/edit/'. $pid);

  309.     $actions = implode('&nbsp;&nbsp;', $actions);

  310.     

  311.     $cells = array();

  312. //     $title = l($pattern->title, 'admin/build/patterns/info/'. $pid, array('class' => 'pattern-title', 'id' => 'pid-'. $pid));

  313.     $title = '<span id="pid-'. $pid .'" class="pattern-title">'. $pattern->title .'</span>';

  314. //     $view_more = '<div>'. t('Clik on pattern title to see more details.') .'</div>';

  315.     $info = array();

  316.     $info[] = t('Author: ') . $pattern->info['author'];

  317.     $info[] = t('Email: ') . $pattern->info['author_email'];

  318.     $info[] = t('Web: ') . $pattern->info['author_website'];

  319.     $author = theme('item_list', $info);  

  320.     $title .= '<div id="pid-'. $pid .'-info" class="pattern-info">'. $author . $pattern->description . $view_more .'</div>';

  321.     $cells[] = $title;

  322.     $cells[] = $pattern->status ? t('Enabled') : t('Disabled');

  323.     $cells[] = $pattern->info['version'];

  324. //     $cells[] = $pattern->public ?  t('Yes') : t('No');

  325.     $cells[] = $actions;

  326.     $category = $pattern->info['category'] ? $pattern->info['category'] : t('Other');

  327.     $rows[$category][] = $cells;

  328.   }

  329.   

  330.   ksort($rows);

  331.   foreach ($rows as $title => $category) {     

  332.     $fieldset = array(

  333.       '#title' => t($title),

  334.       '#collapsible' => TRUE,

  335.       '#collapsed' => FALSE,

  336.       '#value' => theme('table', $header, $category),

  337.     );

  338.     $output .= theme('fieldset', $fieldset);      

  339.   }

  340.   

  341.   return $output;

  342. }

  343. 

  344. /**

  345.  * Menu callback to undo a patterns update changes

  346.  */

  347. function patterns_revert($pid) {

  348.   if ($name = db_result(db_query('SELECT name FROM {patterns} WHERE pid = "%d"', $pid))) {

  349.     $path = file_create_path(variable_get('patterns_save_xml', 'patterns') .'/enabled/'. $name .'.xml');

  350.     $new = db_result(db_query('SELECT file FROM {patterns} WHERE pid = "%d"'));

  351.   }

  352.   else {

  353.     drupal_set_message(t('The pattern you specified does not exist.'), 'error');

  354.     drupal_goto('admin/build/patterns');

  355.   }

  356.   

  357.   if (file_exists($path)) {

  358.     if (file_move($path, $new, FILE_EXISTS_REPLACE)) {

  359.       drupal_set_message(t('This pattern was reverted to the state it was at when it was enabled.'));

  360.       drupal_goto();

  361.     }

  362.   }

  363.   else {

  364.     drupal_set_message(t('The patterns enabled-state was not saved properly, therefore it cannot be reverted.'), 'error');

  365.   }

  366.   

  367.   drupal_goto('admin/build/patterns');

  368. }

  369. 

  370. /**

  371.  * Menu callback to display patterns details page

  372.  */

  373. // function patterns_info($pid = null) {

  374. //   if (!is_numeric($pid)) {

  375. //     drupal_set_message(t('You must specify a pattern.'));

  376. //     return;

  377. //   }

  378. //   

  379. //   $pattern = patterns_get_pattern($pid);

  380. //   

  381. //   $output = '';

  382. //   return $output;

  383. // }

  384. 

  385. /**

  386.  * Menu callback to edit a patterns data

  387.  */

  388. function patterns_edit($pid = null) {

  389.   if (!is_numeric($pid)) {

  390.     drupal_set_message(t('You must specify a pattern to edit.'));

  391.     return;

  392.   }

  393.   

  394.   $pattern = patterns_get_pattern($pid);

  395.   

  396.   // TODO: Turn php into xml here.

  397.   

  398.   // For now just allow modifying the original xml, which 

  399.   // means the modification cannot be further modified

  400.   

  401.   if (!$pattern->file) {

  402.     drupal_set_message(t('This pattern does not seem to have an XML source file to base the modifications off of.'), 'error');

  403.     return;

  404.   }

  405.   

  406.   $xml = file_get_contents($pattern->file);

  407.   

  408.   $form['name'] = array(

  409.     '#type' => 'value',

  410.     '#value' => $pattern->name

  411.   );

  412.   $form['pid'] = array(

  413.     '#type' => 'value',

  414.     '#value' => $pattern->pid

  415.   );

  416.   if ($pattern->enabled <= $pattern->updated) {

  417.     $form['revert'] = array(

  418.       '#type' => 'markup',

  419.       '#value' => l(t('Undo update changes to the state when you enabled the pattern.'), 'admin/build/patterns/revert/'. $pid, array(), drupal_get_destination())

  420.     );

  421.   }

  422.   $form['xml'] = array(

  423.     '#type' => 'textarea',

  424.     '#title' => t('Pattern\'s XML'),

  425.     '#rows' => 25,

  426.     '#default_value' => $xml

  427.   );

  428.   $form['submit'] = array(

  429.     '#type' => 'submit',

  430.     '#value' => t('Submit')

  431.   );

  432.   

  433.   return $form;

  434. }

  435. 

  436. /**

  437.  * Validate pattern modifications (make sure proper XML)

  438.  */

  439. function patterns_edit_validate($form_id, $form_values) {

  440.   // Do validations....

  441.   $path = file_create_path(variable_get('patterns_save_xml', 'patterns'));

  442. 

  443.   if (!file_check_directory($path, true)) {

  444.     form_set_error('form_token', t('Unable to create @path to save the new pattern to.', array('@path' => $path)));

  445.   }

  446. }

  447. 

  448. /**

  449.  * Submit edits to the pattern

  450.  */

  451. function patterns_edit_submit($form_id, $form_values) {

  452.   // If this is an enabled pattern, make sure the enabled pattern is saved in its current state

  453.   if ($file = db_result(db_query('SELECT file FROM {patterns} WHERE status = 1 AND name = "%s"', $form_values['name']))) {

  454.     $dir = file_directory_path() .'/'. variable_get('patterns_save_xml', 'patterns') .'/enabled';

  455.     file_check_directory($dir, true);

  456.     $path =  $dir .'/'. $form_values['name'] .'.xml';

  457.     

  458.     if (!file_exists($path)) {

  459.       file_copy($file, $path, FILE_EXISTS_ERROR);

  460.     }

  461.   }

  462.   

  463.   // Save the new pattern into the pattern files dir.

  464.   $path = file_directory_path() .'/'. variable_get('patterns_save_xml', 'patterns') .'/'. $form_values['name'] .'.xml';

  465.   

  466.   file_save_data($form_values['xml'], $path, FILE_EXISTS_REPLACE);

  467.   

  468.   $old = db_result(db_query('SELECT file FROM {patterns} WHERE name = "%s"', $form_values['name']));

  469.  

  470.   // Load and save pattern

  471.   if ($pattern = patterns_load_xml($path)) {

  472.     if ($old) {

  473.       db_query('UPDATE {patterns} SET file = "%s", updated = "%s" WHERE pid = "%d"', $path, time(), $form_values['pid']);

  474.     }

  475. 

  476.     patterns_save_pattern($pattern, $path);

  477.   }

  478.   

  479.   drupal_set_message(t('%name was saved.', array('%name' => $form_values['name'])));

  480.   

  481.   return 'admin/build/patterns';

  482. }

  483. 

  484. /**

  485.  * List the modules used by a particular pattern

  486.  */

  487. function patterns_modules_page($pid) {

  488.   $pattern = patterns_get_pattern($pid);

  489.   

  490.   drupal_set_title($pattern->title .' '. t('(Pattern Modules)'));

  491.   

  492.   $modules = patterns_modules($pattern);

  493.   $modules_info = module_rebuild_cache();

  494.   $modules_list = module_list();

  495.   

  496.   // Get module name, whether its to be disabled or enabled,

  497.   // whether the module is available or not, and whether it is

  498.   // currently enabled or not

  499.   foreach($modules as $module) {

  500.     $row = array();

  501.     $delete = is_array($module) ? $module['delete'] : false;

  502.     $module = is_array($module) ? $module['value'] : $module;

  503.     $available = array_key_exists($module, $modules_info);

  504.     $enabled = array_key_exists($module, $modules_list);

  505.     $row[] = $module;

  506.     $row[] = $available ? t('Yes') : '<span class="alert">'. t('No') .'</span>';

  507.     $row[] = $enabled ? t('Yes') : '<span class="alert">'. t('No') .'</span>';

  508.     $row[] = $delete ? t('Delete') : t('Enable');

  509.     $rows[] = $row;

  510.     

  511.     if (!$available) {

  512.       $not_available = true;

  513.     }

  514.   }

  515.   

  516.   if ($not_available) {

  517.     drupal_set_message(t('Some modules are not availalble, please download them before running this pattern.'), 'error');

  518.   }

  519.   else {

  520.     drupal_set_message(t('All modules required by this module are available. Click !here to run this pattern.', array('!here' => l(t('here'), 'admin/build/patterns/enable/'. $pid))));

  521.   }

  522.   

  523.   return theme('table', array(t('Name'), t('Available'), t('Enabled'), t('Pattern Action')), $rows, t('Modules used for this pattern'));

  524. }

  525. 

  526. function patterns_load() {

  527.   static $loaded = false;

  528.   

  529.   if ($loaded) {

  530.     return;

  531.   }

  532.   

  533.   require_once drupal_get_path('module', 'patterns') .'/patterns.inc';

  534.   

  535.   foreach(file_scan_directory(drupal_get_path('module', 'patterns') .'/components', '.\.inc') as $file) {

  536.     include_once $file->filename;

  537.   }

  538.   

  539.   $loaded = true;

  540. }

  541. 

  542. function patterns_get_patterns($reset = true) {

  543.   patterns_load();

  544.   

  545.   if ($reset || !variable_get('patterns_loaded', false)) {

  546.     // Get a listing of enabled patterns

  547.     $enabled = array();

  548.     $result = db_query('SELECT file FROM {patterns} WHERE status = 1');

  549.     

  550.     while ($pattern = db_fetch_object($result)) {

  551.       $enabled[] = $result->file;

  552.     }

  553.     

  554.     $path = file_create_path(variable_get('patterns_save_xml', 'patterns'));

  555.     $priority = array();

  556.     

  557.     // Get uploaded patterns first

  558.     if (file_check_directory($path)) {

  559.       // Check if .htaccess file exists in path, if not insert it

  560.       _patterns_check_file_dir();

  561. 

  562.       foreach(file_scan_directory($path, '.\.xml') as $file) {

  563.         // Don't save enabled pattern backups

  564.         if (strpos($file->filename, $path .'/enabled/') === 0) {

  565.           continue;

  566.         }

  567.         

  568.         // Set priority so these patterns won't get over-written

  569.         $priority[] = $file->name;

  570.         

  571.         // Can't update existing patterns that are enabled

  572.         if (in_array($file->filename, $enabled)) {

  573.           continue;

  574.         }

  575.         

  576.         // Load and save pattern

  577.         if ($pattern = patterns_load_xml($file->filename)) {

  578.           patterns_save_pattern($pattern, $file->filename);

  579.         }

  580.       }

  581.     }

  582. 

  583.     // Get per-site patterns next

  584.     foreach(file_scan_directory(conf_path() .'/patterns', '.\.xml') as $file) {

  585.       // Can't update existing patterns that are enabled

  586.       if (in_array($file->filename, $enabled) || in_array($file->name, $priority)) {

  587.         continue;

  588.       }

  589.       

  590.       $priority[] = $file->name;

  591.       

  592.       // Load and save pattern

  593.       if ($pattern = patterns_load_xml($file->filename)) {

  594.         patterns_save_pattern($pattern, $file->filename);

  595.       }

  596.     }

  597.     

  598.     // Get profile patterns next

  599.     global $profile;

  600.     foreach(file_scan_directory('profiles/'. $profile .'/patterns', '.\.xml') as $file) {

  601.       // Can't update existing patterns that are enabled

  602.       if (in_array($file->filename, $enabled) || in_array($file->name, $priority)) {

  603.         continue;

  604.       }

  605.       

  606.       $priority[] = $file->name;

  607.       

  608.       // Load and save pattern

  609.       if ($pattern = patterns_load_xml($file->filename)) {

  610.         patterns_save_pattern($pattern, $file->filename);

  611.       }

  612.     }

  613.     

  614.     // Last get the default patterns

  615.     foreach(file_scan_directory(drupal_get_path('module', 'patterns') .'/patterns', '.\.xml') as $file) {

  616.       // Can't update existing patterns that are enabled

  617.       if (in_array($file->filename, $enabled) || in_array($file->name, $priority)) {

  618.         continue;

  619.       }

  620.       

  621.       $pattern = patterns_load_xml($file->filename);

  622.       

  623.       // Load and save pattern

  624.       if ($pattern = patterns_load_xml($file->filename)) {

  625.         patterns_save_pattern($pattern, $file->filename);

  626.       }

  627.     }

  628.     

  629.     variable_set('patterns_loaded', time());

  630.   }

  631.   

  632.   $result = db_query('SELECT * FROM {patterns}');

  633.   

  634.   while ($pattern = db_fetch_object($result)) {

  635.     $patterns[$pattern->pid] = $pattern;

  636.     $data = unserialize($patterns[$pattern->pid]->pattern);

  637.     $patterns[$pattern->pid]->pattern = $data;

  638.     foreach ($data as $key => $section) {

  639.       if ($data[$key]['tag'] == 'info') {       

  640.         $patterns[$pattern->pid]->info = array();

  641.         array_shift($section);

  642.         foreach($section as $property) {

  643.           $patterns[$pattern->pid]->info[$property['tag']] = $property['value'];

  644.         }

  645.       }  

  646.     }

  647.   }

  648.   

  649.   return $patterns;

  650. }

  651. 

  652. function patterns_save_pattern($pattern, $xmlpath = '') {

  653.   $name = basename($xmlpath, '.xml');

  654.   

  655.   foreach($pattern[0] as $index => $value) {

  656.     if (is_numeric($index)) {

  657.       switch($value['tag']) {

  658.         case 'title':

  659.           $title = $value['value'];

  660.         break;

  661.         case 'description':

  662.           $description = $value['value'];

  663.         break;

  664.         case 'author':

  665.           $author = $value['value'];

  666.         break;

  667.       }

  668.     }

  669.   }

  670.   

  671.   if ($pid = db_result(db_query('SELECT pid FROM {patterns} WHERE name = "%s"', $name))) {

  672.     $updated = db_result(db_query('SELECT updated FROM {patterns} WHERE pid = "%d"', $pid));

  673.     if (($new_updated = filemtime(file_create_path($xmlpath))) > $updated) {

  674.     	db_query('UPDATE {patterns} SET pattern = "%s", title = "%s", file = "%s", updated = "%s", description = "%s" WHERE pid = %d', serialize($pattern), $title, $xmlpath, $new_updated, $description, $pid);

  675.     }

  676.     else {

  677.     	db_query('UPDATE {patterns} SET pattern = "%s", title = "%s", file = "%s", description = "%s" WHERE pid = %d', serialize($pattern), $title, $xmlpath, $description, $pid);

  678.     }

  679.   }

  680.   else {

  681.     $pid = db_next_id('{patterns}_pid');

  682.     db_query('INSERT INTO {patterns} VALUES(%d, "%s", 0, "%s", "%s", 0, "%s", "%s", "%s")', $pid, $name, $xmlpath, time(), $title, $description, serialize($pattern));

  683.   }

  684. }

  685. 

  686. function patterns_get_pattern($id) {

  687.   if (is_numeric($id)) {

  688.     $pattern = db_fetch_object(db_query('SELECT * FROM {patterns} WHERE pid = "%d"', $id));

  689.   }

  690.   else if (is_string($id)) {

  691.     $pattern = db_fetch_object(db_query('SELECT * FROM {patterns} WHERE name = "%s"', $id));

  692.   }

  693.   

  694.   // Get the actual data. Data is stored in serialized form in the db.

  695.   $pattern->pattern = unserialize($pattern->pattern);

  696.   

  697.   // Rearrange the data in a nice way for each component.

  698.   // Make sure actions are processed differently so order is preserved.

  699.   $pattern->pattern = patterns_rearrange_data($pattern->pattern);

  700.   

  701.   return $pattern;

  702. }

  703. 

  704. function patterns_load_xml($path) {

  705.   if (!file_exists($path)) {

  706.     return;

  707.   }

  708.   

  709.   $xml = file_get_contents($path);

  710.   

  711.   $pattern = patterns_from_source($xml);

  712.   

  713.   return $pattern;

  714. }

  715. 

  716. /**

  717.  * Create a pattern from an XML data source

  718.  */

  719. function patterns_from_source($xml) {

  720.   $parse = xml_parser_create();

  721.   xml_parse_into_struct($parse, $xml, $vals, $index);

  722.   

  723.   // Create a multi-dimensional array representing the XML structure

  724.   $pattern = current(_patterns_parse_tag($vals, 0));

  725.   

  726.   return $pattern;

  727. }

  728. 

  729. /**

  730.  * Recurse through the values of a parsed xml file to create a

  731.  * multi-dimensional representation of the data.

  732.  */

  733. function _patterns_parse_tag($data, $index) {

  734.   $pattern = array();

  735.   

  736.   while ($current = $data[$index]) {

  737.     $type = $current['type'];

  738.     

  739.     foreach((array)$current['attributes'] as $key => $value) {

  740.       $current[strtolower($key)] = $value;

  741.     }

  742.     

  743.     $current['tag'] = strtolower($current['tag']);

  744.     

  745.     unset($current['type'], $current['level'], $current['attributes']);

  746.     

  747.     if (!trim($current['value']) && $current['value'] != "0") {

  748.       unset($current['value']);

  749.     }

  750.     

  751.     switch($type) {

  752.       case 'open':

  753.         $index++;

  754.         $current += _patterns_parse_tag($data, &$index);

  755.         $pattern[] = $current;

  756.       break;

  757.       case 'close':

  758.         $index++;

  759.         return $pattern;

  760.       break;

  761.       case 'complete':

  762.         // In order to support more complex/non-standard features we can use serialized data

  763.         if ($current['attributes']['serialized']) {

  764.           $value = unserialize($current['value']);

  765.           

  766.           if (isset($value)) {

  767.             $current['value'] = $value;

  768.           }

  769.         }

  770.         

  771.         // This enables tags like <blog /> to turn into array('blog' => 'blog')

  772.         // which is useful for checkbox/select type forms

  773.         if (!isset($current['value'])) {

  774.           $current['value'] = $current['tag'];

  775.         }

  776. 

  777.         $pattern[] = $current;

  778.       break;

  779.     }

  780.     

  781.     $index++;

  782.   }

  783.   

  784.   return $pattern;

  785. }

  786. 

  787. function patterns_disable_pattern($pid) {

  788.     $form['pid'] = array(

  789.     '#type' => 'value',

  790.     '#value' => $pid

  791.   );

  792.   

  793.   $pattern = patterns_get_pattern($pid);

  794. 

  795.   return confirm_form($form, t('Proceed with disabling pattern %pattern?', array('%pattern' => $pattern->title)), 'admin/build/patterns', '');

  796. }

  797. 

  798. function patterns_enable_pattern($pid) {

  799.   $form['pid'] = array(

  800.     '#type' => 'value',

  801.     '#value' => $pid

  802.   );

  803.   

  804.   $disclaimer = t('Please be sure to backup your site before running a pattern. Patterns are not guaranteed to be reversable in case they do not execute well or if unforseen side effects occur.');

  805.   

  806.   $pattern = patterns_get_pattern($pid);

  807. 

  808.   return confirm_form($form, t('Proceed with running pattern %pattern?', array('%pattern' => $pattern->title)), 'admin/build/patterns', $disclaimer);

  809. }

  810. 

  811. function patterns_disable_pattern_submit($form_id, $form_values) {

  812.   $pid = $form_values['pid'];

  813.   $pattern = patterns_get_pattern($pid);

  814.   

  815.   if (patterns_execute_pattern($pattern, true, true)) {

  816.     return 'admin/build/patterns';

  817.   }

  818. }

  819. 

  820. function patterns_enable_pattern_submit($form_id, $form_values) {

  821.   $pid = $form_values['pid'];

  822.   

  823.   patterns_load();

  824.   $pattern = patterns_get_pattern($pid);

  825.   

  826.   if (patterns_execute_pattern($pattern, false, true)) {

  827.     return 'admin/build/patterns';

  828.   }

  829. }

  830. 

  831. function patterns_execute_pattern($pattern, $reverse = false, $interact = false, $jump = null) {

  832.   patterns_load();

  833.   set_time_limit(0);

  834. 

  835.   if (!is_object($pattern)) {

  836.     $pattern = patterns_get_pattern($pattern);

  837.     

  838.     if (!$pattern) {

  839.       return false;

  840.     }

  841.   }

  842.   

  843.   $errors = $action_list = $identifiers = array();

  844.   $error = true;

  845.   

  846.   // Pattern info

  847.   $status = $pattern->status;

  848.   $title = $pattern->title;

  849.   $pid = $pattern->pid;

  850.   

  851.   // From here on out just need the actual pattern data

  852.   $pattern = $pattern->pattern;

  853.   

  854.   // Split the pattern up into modules and actions. Submit modules as its

  855.   // own pattern programattically.

  856.   $modules = $actions = array();

  857.   for($i=0;$tag=$pattern[$i];$i++) {

  858.     if ($tag['tag'] == 'modules') {

  859.       $modules = $tag;

  860.     }

  861.     else if ($tag['tag'] == 'actions') {

  862.       $actions = $tag;

  863.       unset($actions['tag']);

  864.     }

  865.   }

  866.   

  867.   // If there are no actions or modules, most likely the pattern

  868.   // was not created correctly.

  869.   if (empty($actions) && empty($modules)) {

  870.     drupal_set_message(t('Could not recognize pattern %title, aborting.', array('%title' => $title)), 'error');

  871.     return true;

  872.   }

  873.   

  874.   if ($modules && (!$interact || ($interact && !$jump))) {

  875.     // Make the modules look like a normal pattern so they can be executed

  876.     // on their own.

  877.     $obj = new stdClass();

  878.     $obj->title = t('Enable/disable %title pattern modules', array('%title' => $title));

  879.     $obj->status = $status;

  880.     $obj->pattern = array(array('tag' => 'actions', $modules));

  881.     $modules = $obj;

  882.     

  883.     // Modules need to be enabled first so the rest of the pattern

  884.     // can proceed smoothly.

  885.     if (!$reverse) {

  886.       $error = patterns_execute_pattern($modules, $reverse, $interact);

  887.       module_rebuild_cache();

  888.     }

  889.   }

  890.   

  891.   // Keep a list of what modules handle what tags

  892.   $tag_modules = patterns_invoke($empty, 'tag modules');

  893.   

  894.   // If an interactive pattern needs resuming, remove the

  895.   // already executed actions

  896.   if ($interact && $jump > 0) {

  897.     array_splice($actions, 0, $jump);

  898.   }

  899.   

  900.   // Prepare actions for validation/processing

  901.   foreach($actions as $key => $data) {

  902.     patterns_invoke($actions[$key], 'prepare');

  903.   }

  904.   

  905.   // Reverse a pattern for disabling

  906.   if ($reverse && $status) {

  907.     $actions = array_reverse($actions);

  908.     

  909.     foreach($actions as $key => $data) {

  910.       $continue = patterns_invoke($data, 'reverse');

  911.       

  912.       if ($continue === false) {

  913.         drupal_set_message(t('[Error] Disabling of this pattern is not supported at this time.'));

  914.         return false;

  915.       }

  916.       

  917.       $actions[$key] = $data;

  918.     }

  919.   }

  920.   

  921.   // Pre validate tags with their appropriate components

  922.   foreach($actions as $key => $data) {

  923.     if (!array_key_exists($data['tag'], $tag_modules)) {

  924.       $errors[$data['tag']][] = t('Invalid Pattern: <%tag> is not a valid tag', array('%tag' => $data['tag']));

  925.     }

  926.     else {

  927.       $error = patterns_invoke($data, 'pre-validate');

  928.       if ($error) {

  929.         $errors[$data['tag']][] = t('Invalid Pattern: !msg', array('!msg' => $error));

  930.       }

  931.     }

  932.   }

  933.   

  934.   if (count($errors)) {

  935.     foreach($errors as $error) {

  936.       drupal_set_message(implode('<br>', $error), 'error');

  937.     }

  938.     

  939.     return;

  940.   }

  941.   

  942.   // Build and execute a list of actions

  943.   foreach($actions as $key => $data) {

  944.     // Prepare actions for processing, ensure smooth pattern executions, and return form ids for execution

  945.     $return = patterns_invoke($data, 'form_id');

  946.     

  947.     // If prepare removed the data, dont continue with this action

  948.     if (!$data || !$return) {

  949.       continue;

  950.     }

  951.     

  952.     if (is_string($return)) {

  953.       $form_ids = array($return);

  954.     }

  955.     else if ($return) {

  956.       $form_ids = $return;

  957.     }

  958.     

  959.     // Build the action

  960.     foreach($form_ids as $form_id) {

  961.       $clone = $data;

  962.       $error = patterns_invoke($clone, 'validate', $form_id);

  963.       

  964.       if ($error) {

  965.         if (is_array($error)) {

  966.           foreach($error as $msg) {

  967.             drupal_set_message($msg, 'error');

  968.           }

  969.           

  970.           $errors[$clone['tag']] = t('Broken Pattern: %msg', array('%msg' => implode('<br>', $error)));

  971.         }

  972.         else {

  973.           drupal_set_message($error, 'error');

  974.           $errors[$clone['tag']] = t('Broken Pattern: %msg', array('%msg' => $error));

  975.         }

  976.         

  977.         

  978.         return;

  979.       }

  980.       

  981.       // If tokens are enabled, apply tokens to the action values

  982.       // before processing

  983.       if (module_exists('token')) {

  984.         _patterns_recurse_tokens($clone, $identifiers);

  985.         //array_walk($clone, '_patterns_replace_tokens', $identifiers);

  986.       }

  987. 

  988.       // Get the form data for the action

  989.       $values = patterns_invoke($clone, 'build', $form_id);

  990.       

  991.       // Dont execute the action if a string was returned, indicating the pattern component

  992.       // most likely handled the action on its own and this is the message to display.

  993.       if (is_string($values)) {

  994.         drupal_set_message($values);

  995.       }

  996.       else {

  997.         // Get any extra parameters required for the action

  998.         $params = patterns_invoke($clone, 'params', $form_id, $values);

  999.         

  1000.         if (isset($params) && !is_array($params)) {

  1001.           $params = array($params);

  1002.         }

  1003.       

  1004.         // Execute action

  1005.         patterns_execute_action($form_id, $values, $params);

  1006.                 

  1007.         if (form_get_errors()) {

  1008.           $descriptions = patterns_invoke($clone, 'actions');

  1009.           

  1010.           drupal_set_message(t('An error occured running action #%num (%action)', array('%num' => $key+1, '%action' => $descriptions[$form_id])), 'error');

  1011.           $error = true;

  1012.           break;

  1013.         }

  1014.       }

  1015.       

  1016.       patterns_invoke($clone, 'cleanup', $form_id);

  1017.       

  1018.       // Clear the cache in case it causes problems

  1019.       cache_clear_all();

  1020.     }

  1021.     if ($error) {

  1022.       break;

  1023.     }

  1024.     

  1025.     // Get any primary identifiers from the action for further actions to take advantage of

  1026.     $id = null;

  1027.     $id = patterns_invoke($clone, 'identifier', $form_id);

  1028.     if (isset($id)) {

  1029.       $identifiers[$key+1] = $id;

  1030.     }

  1031.   }

  1032.   

  1033.   if (empty($errors)) {

  1034.     if ($reverse) {

  1035.       if ($modules) {

  1036.         // Modules need to be disabled last so the rest of the pattern

  1037.         // can reverse itself properly

  1038.         $error = patterns_execute_pattern($modules, $reverse, $interact);

  1039.       }

  1040.       

  1041.       // Mark pattern as disabled

  1042.       if ($pid) {

  1043.         db_query('UPDATE {patterns} SET status = 0 WHERE pid = %d', $pid);

  1044.       }

  1045.       

  1046.       drupal_set_message(t('Pattern reversed successfully.'));

  1047.     }

  1048.     else {

  1049.       // Mark pattern as enabled

  1050.       if ($pid) {

  1051.         db_query('UPDATE {patterns} SET status = 1, enabled = "%s" WHERE pid = %d', time(), $pid);

  1052.       }

  1053.       

  1054.       drupal_set_message(t('Pattern ran successfully.'));

  1055.     }

  1056.   }

  1057.   

  1058.   return !$error;

  1059. }

  1060. 

  1061. /**

  1062.  * Execute an action

  1063.  */

  1064. function patterns_execute_action($form_id, $values, $params) {

  1065.   // Make sure we always have a clear cache for everything

  1066.   $result = db_query('SHOW TABLES LIKE "cache_%"');

  1067.   

  1068.   while ($table = db_fetch_array($result)) {

  1069.     $table = current($table);

  1070.     cache_clear_all(null, $table);

  1071.   }

  1072.   

  1073.   $args = array($form_id, $values);

  1074.   

  1075.   if (is_array($params)) {

  1076.     $args = array_merge($args, $params);

  1077.   }

  1078.   

  1079.   patterns_executing(true);

  1080.   

  1081.   //$form = call_user_func_array('drupal_retrieve_form', $args);

  1082.   //$form['#post'] = $values;

  1083.   //$return = drupal_process_form($form_id, $form);

  1084.   

  1085.   $return = call_user_func_array('drupal_execute', $args);

  1086.   

  1087.   patterns_executing(false);

  1088.   

  1089.   return $return;

  1090. }

  1091. 

  1092. function patterns_executing($b = null) {

  1093.   static $executing = false;

  1094.   

  1095.   if (is_bool($b)) {

  1096.     $executing = $b;

  1097.   }

  1098.   

  1099.   return $executing;

  1100. }

  1101. 

  1102. function patterns_rearrange_data($pattern) {

  1103.   foreach($pattern as $key => $value) {

  1104.     if (is_string($key)) {

  1105.       unset($pattern[$key]);

  1106.     }

  1107.     else {

  1108.       if ($value['tag'] == 'actions') {

  1109.         $pattern[$key] = patterns_rearrange_data($value);

  1110.         $pattern[$key]['tag'] = 'actions';

  1111.       }

  1112.       else {

  1113.         $pattern[$key] = _patterns_rearrange_data($value);

  1114.       }

  1115.     }

  1116.   }

  1117.   

  1118.   return $pattern;

  1119. }

  1120. 

  1121. /**

  1122.  * Return a list of modules for a pattern

  1123.  */

  1124. function patterns_modules($pattern) {

  1125.   $pattern = $pattern->pattern;

  1126.   

  1127.   for($i=0;$tag=$pattern[$i];$i++) {

  1128.     if ($tag['tag'] == 'modules') {

  1129.       unset($tag['tag']);

  1130.       $modules = $tag;

  1131.       break;

  1132.     }

  1133.   }

  1134.   

  1135.   return $modules;

  1136. }

  1137. 

  1138. function patterns_process_modules($modules, $op = 'enable') {

  1139.   // Enable at the beginning of the pattern. Disable at the end.

  1140.   for($i=0;$module=$modules[$i];$i++) {

  1141.     if (($op == 'enable' && $module['delete']) || ($op == 'disable' && !$module['delete'])) {

  1142.       unset($modules[$i]);

  1143.     }

  1144.   }

  1145.   

  1146.   patterns_invoke($empty, 'tag modules');

  1147.   $error = patterns_invoke($modules, 'pre-validate');

  1148.   

  1149.   // Error validating modules

  1150.   if ($error) {

  1151.     return $error;

  1152.   }

  1153.   

  1154.   patterns_invoke($modules, 'prepare');

  1155. }

  1156. 

  1157. function patterns_invoke(&$data, $op, $form_id = null, $a = null) {

  1158.   static $tag_modules;

  1159.     

  1160.   if (!is_array($tag_modules) || $op == 'tag modules') {

  1161.     // Get a list of tags and their modules

  1162.     foreach(module_implements('patterns') as $module) {

  1163.       $tags = module_invoke($module, 'patterns', 'tags');

  1164.       

  1165.       foreach($tags as $tag => $value) {

  1166.         if (is_array($value)) {

  1167.           $tag_modules[$tag] = $module;

  1168.         }

  1169.         else {

  1170.           $tag_modules[$value] = $module;

  1171.         }

  1172.       }

  1173.     }

  1174.   }

  1175.   

  1176.   // If you just want the modules list

  1177.   if ($op == 'tag modules') {

  1178.     return $tag_modules;

  1179.   }

  1180. 

  1181.   $tag = $data['tag'];

  1182.   unset($data['tag']);

  1183.   

  1184.   $module = $tag_modules[$tag];

  1185.   $func = $module .'_patterns';

  1186.   

  1187.   if (function_exists($func)) {

  1188.     if ($form_id) {

  1189.       $return = $func($op, $form_id, $data, $a);

  1190.     }

  1191.     else {

  1192.       $return = $func($op, $tag, $data, $a);

  1193.     }

  1194.   }

  1195.   

  1196.   $data['tag'] = $tag;

  1197.   return $return;

  1198. }

  1199. 

  1200. function _patterns_rearrange_data($data, $parent = '') {

  1201.   $numeric = array();

  1202.   $count=0;

  1203.   

  1204.   foreach($data as $key => $value) {

  1205.     if ($value['value'] == 'false') {

  1206.       $value['value'] = false;

  1207.     }

  1208.     else if ($value['value'] == 'true') {

  1209.       $value['value'] = true;

  1210.     }

  1211.     

  1212.     if (is_numeric($key) && is_array($value) && count($value) == 2 && isset($value['tag']) && isset($value['value'])) {

  1213.       unset($data[$key]);

  1214.       if (isset($data[$value['tag']])) {

  1215.         $numeric[] = $value['tag'];

  1216.         $data[$count++] = $data[$value['tag']];

  1217.         $data[$count++] = $value['value'];

  1218.         unset($data[$value['tag']]);

  1219.       }

  1220.       else if (in_array($value['tag'], $numeric)) {

  1221.         $data[$count++] = $value['value'];

  1222.       }

  1223.       else {

  1224.         $data[$value['tag']] = $value['value'];

  1225.       }

  1226.     }

  1227.     else if (is_numeric($key)) {

  1228.       $tag = $value['tag'];

  1229.       unset($value['tag']);

  1230.       $data[$tag][] = _patterns_rearrange_data($value, $tag);

  1231.       unset($data[$key]);

  1232.     }

  1233.   }

  1234.   

  1235.   foreach($data as $key => $value) {

  1236.     if (is_array($value) && count($value) == 1 && $value[0]) {

  1237.       $data[$key] = $data[$key][0];

  1238.     }

  1239.   }

  1240.   

  1241.   return $data;

  1242. }

  1243. 

  1244. 

  1245. function patterns_form_alter($form_id, &$form) {

  1246.   if (user_access('administer patterns') && variable_get('patterns_form_helper', true)) {

  1247.     $form['#after_build'][] = 'patterns_form_helper';

  1248.   }

  1249. }

  1250. 

  1251. function patterns_form_helper($form) {

  1252.   global $form_submitted;

  1253. //  static $form_id, $form_values;

  1254.   $args = func_get_args();

  1255.   

  1256.   if (!$form_id && $form_submitted) {

  1257.     $form_values = $args[1];

  1258.     $form_id = $form_values['form_id'];

  1259.     

  1260.     $_SESSION['patterns_form_helper'] = array('form_id' => $form_id, 'form_values' => $form_values);

  1261.   }

  1262.   

  1263.   return $form;

  1264. }

  1265. 

  1266. function patterns_init() {

  1267.   if (variable_get('patterns_form_helper', true) && $_SESSION['patterns_form_helper']) {

  1268.     drupal_add_css(drupal_get_path('module', 'patterns') .'/patterns.css');

  1269.     drupal_add_js(drupal_get_path('module', 'patterns') .'/patterns.js');

  1270.   }

  1271. }

  1272. 

  1273. function patterns_exit($destination = null) {

  1274.   if (variable_get('patterns_form_helper', true) && $_SESSION['patterns_form_helper'] && !$destination) {

  1275.     print theme('patterns_form_helper', $_SESSION['patterns_form_helper']['form_id'], $_SESSION['patterns_form_helper']['form_values']);

  1276.     //unset($_SESSION['patterns_form_helper']);

  1277.   }

  1278. }

  1279. 

  1280. /**

  1281.  * Implementation of hook_token_values()

  1282.  * 

  1283.  * @If these get implementated directly into token.module, this should be removed

  1284.  */

  1285. function patterns_token_values($type, $object = NULL, $options = array()) {

  1286.   if ($type == 'global') {

  1287.     $path = conf_path();

  1288.     $tokens['confpath'] = $path;

  1289.     return $tokens;

  1290.   }

  1291. }

  1292. 

  1293. /**

  1294.  * Function callback

  1295.  */

  1296. function _patterns_modify_value(&$form) {

  1297.   foreach($form as $key => $value) {

  1298.     if (is_array($value) && isset($value['#type']) && $value['#type'] == 'value') {

  1299.       $form[$key]['#default_value'] = $value['#value'];

  1300.       unset($form[$key]['#value']);

  1301.     }

  1302.     else if (is_array($value)) {

  1303.       _patterns_modify_value($form[$key]);

  1304.     }

  1305.   }

  1306. }

  1307. 

  1308. /**

  1309.  * Recurse an array and replace with tokens

  1310.  * @ This is used instead of array_walk_recursive because

  1311.  *   of some strange issues with token_get_values failing.

  1312.  */

  1313. function _patterns_recurse_tokens(&$object, $identifiers) {

  1314.   foreach($object as $key => $value) {

  1315.     if (is_array($value)) {

  1316.       _patterns_recurse_tokens($object[$key], $identifiers);

  1317.     }

  1318.     else if (is_scalar($value)) {

  1319.       $old_key = $key;

  1320.       _patterns_replace_tokens($object[$key], $key, $identifiers);

  1321.       

  1322.       // The key was changed, change it

  1323.       if ($old_key != $key) {

  1324.         $keys = array_keys($object);

  1325.         $keys[array_search($old_key, $keys)] = $key;

  1326.         $object = array_combine($keys, array_values($object));

  1327.       }

  1328.     }

  1329.   }

  1330. }

  1331. 

  1332. /**

  1333.  * Array walk callback to replace tokens inside form values

  1334.  */

  1335. function _patterns_replace_tokens(&$a, &$b, $identifiers = array()) {

  1336.   static $count = 0;

  1337. 

  1338.   // Replace IDs with identifiers from the current executing pattern

  1339.   if (preg_match('/@([0-9]+)@/', $a, $match)) {

  1340.     $a = str_replace($match[0], $identifiers[$match[1]], $a);

  1341.   }

  1342.   if (preg_match('/__([0-9]+)__/', $b, $match)) {

  1343.     $b = str_replace($match[0], $identifiers[$match[1]], $a);

  1344.   }

  1345. 

  1346.   // Replace tokens

  1347.   $a = token_replace($a, 'global', NULL, '@', '@');

  1348.   $b = token_replace($b, 'global', NULL, '__', '__');

  1349. }

  1350. 

  1351. /**

  1352.  * Check if a .htaccess file exists to prevent downloads of pattern files

  1353.  */

  1354. function _patterns_check_file_dir() {

  1355.   return false;

  1356.   $path = file_create_path(variable_get('patterns_save_xml', 'patterns'));

  1357.   

  1358.   if (!is_file($path .'/.htaccess')) {

  1359.     $content = '# Prevent downloading site patterns

  1360. <FilesMatch "\.xml$">

  1361.   Order allow,deny

  1362. </FilesMatch>

  1363. ';

  1364.     file_save_data($content, $path .'/.htaccess');

  1365.   }

  1366. }

  1367. 

  1368. function theme_patterns_form_helper_menu($forms) {

  1369.   $output = '<ul class="patterns-form-menu">';

  1370.   

  1371.   foreach ($forms as $form_id => $values) {

  1372.     $output .= '<li class="patterns-form-menu-item">'. $form_id .'</li>';

  1373.   }

  1374.   

  1375.   $output .= '</li>';

  1376.   

  1377.   return $output;

  1378. }

  1379. 

  1380. function theme_patterns_form_helper($form_id, $values) {

  1381.   $output = '<div class="patterns-form" id="patterns-form-'. $form_id .'">';

  1382.   

  1383.   $output .= '<div class="patterns-form-title">'. t('Form values for %key', array('%key' => $form_id)) .'</div>';

  1384.   

  1385.   foreach($values as $key => $value) {

  1386.     $output .= '<div class="patterns-form-item"><div class="patterns-form-key">'. $key .' => </div>';

  1387.     $output .= '<div class="patterns-form-value">'. print_r($value, true) .'</div></div>';

  1388.   }

  1389.   

  1390.   $output .= '</div>';

  1391.   

  1392.   return $output;

  1393. }

  1394.