/ - Diff - Club Drupal - Forge Centrale Marseille

     CHANGELOG for Diff 7.x-2.0+13-dev to 7.x-3.x
     ============================================
 ) System variable names have been changed
     ------------------------------------------
     Considerable changes have occurred.
 ) hook_diff() was removed
     --------------------------
     This has been replaced by hook_entity_diff() as of Diff 7.x-3.x.
 ) Field diffs are handled independently by Diff and the field module
     ---------------------------------------------------------------------
     Field modules SHOULD NOT implement hook_entity_diff().
     This is complicated and costly in terms of performance.
     Two new field callbacks are defined to handle these.
       a) MODULE_field_diff_view_prepare()
       Optional: If you need to load data, use MODULE_field_diff_view_prepare().
       b) MODULE_field_diff_view()
       Recommended: You should implement this to generate the compared data.
     If there is no corresponding hook for a field, the field comparison will try
     to guess the value using $item['safe_value'] or $item['value'] properties.
     If you need to make this configurable, there are two additional hooks:
       c) MODULE_field_diff_default_options($field_type)
       You should define any additioal settings here. This shares a global namespace
       of the diff module, so you can overwrite core Diff settings here too.
       In saying that, take care not to accidentially do this.
       d) MODULE_field_diff_options_form($field_type, $settings)
       This is where you insert Form API elements to configure your option settings.
 ) Field diffs are now configurable
     -----------------------------------
     Each field type defined by core have configurable settings to control the
     rendering of the comparison.
       a) Global configuration
       An administration page has been added to handle field type default settings.
       This is the preferred way to configure field settings are these are global to
       all fields of this type.
       b) View mode display options
       The display "Diff comparison" is used to control the fields that are displayed
       when comparing different revisions.
       The following is a walk-through on how you would configure the Basic page
       (page) content types field configuration.
       - Enable "Diff comparison" custom view mode
         Navigate to admin/structure/types/manage/page/display and look at the
         Custom Display Settings for this view mode. Check and save.
       - Configure the display
         After Saving this page, a new tab appears "Diff comparison", click this or
         navigate directly to admin/structure/types/manage/page/display/diff_standard
         - You can hide or show the fields that you want to display when doing
           comparisons.
         - If the field has no inbuilt diff support, then the renderred field items
           will be compared.
 ) Standard comparison preview / Inline diff view setting
     ---------------------------------------------------------
     You can set the view modes used to compare the rendered node. This can be found
     in the Diff settings in the Content Type settings page.
 ) Optional CSS and new Boxes styles
     ------------------------------------
     This takes the styles from WikiPedia to really spice up the diff page.
 ) Optional JScript extras
     --------------------------
     This spices up the revision checkboxes on the revisions page.
 ) Simple past revision token support
     -------------------------------------
     Use-case, email notifications when content has changes. If these support tokens,
     then you can embed Diffs into these emails.
 ) Extensive string review
     --------------------------
     See http://drupal.org/node/1785742
 ) Inline block settings changes
     ---------------------------------
     The inline block settings are now in the block configuration page.
 ) And much more...
     --------------------
     The complete change log follows:
     Diff 7.x-2.x
         o #888680 by Deciphered, Alan D.: Allow modules to interact via drupal_alter()
         o #1280892 by Alan D., crea: Diff should track the variables that it defines
         o #1304658 by Alan D., kari.kaariainen: Remove links and comments from the comparison preview
         o #1122206 by binford2k, Alan D.: Notices thrown by DiffEngine::process_chunk()
         o #1175064 by zilverdistel, Alan D.: Provide variables for leading and trailing context
         o #1673864 by Alan D.: Allow users to bypass the admin theme when viewing comparisons
         o #1673876 by Alan D.: Use Drupal autoloading for classes
         o #1673856 by Alan D.: Use hook_form_BASE_FORM_ID_alter() rather than hook_form_alter()
         o #1673856 by Alan D.: Normalise line endings
         o #114308 by Alan D.: add jQuery for hiding radios that shouldn't show diffs
         o #1688840 by Alan D.: Enable new JScript behaviour by default
         o #372957 by erykmynn, JuliaKM, lsrzj, andrew_rs, alexpott, et al: HTML Strip for Diff, WYSIWYG Friendly
           (This was refactored in the 7.x-3.x branch from the commited 7.x-2.x code)
         o #521212 by Alan D., blakehall: Make diff comparison page themable
         o #1671484 by Alan D.: Show number of lines changed on revisions page
         o #114699 by smokris, Alan D.: Diff module should support Token
         o #372957 by c31ck: display either Hide or Show based on what clicking it will do at any time (HTML Strip for Diff)
           This was altered for the 7.x-3.x branch.
         o #1807510 & #1825202: Simplify Diff administration
         o #1812162 by mitchell, Alan D.: 'Highlight changes' block appears on edit form
         Node to Entity changes
         ----------------------
         These are roughly tracked in the meta issue #1365750 Generalize API and Integrate with core field types
         o (no issue) by Alan D.: Use entity specific system variables.
         o (no issue) by Alan D.: View mode code, new hooks, new API. Massive patch!
         Resolves:
         o #248778: Taxonomy diff
         o #1550698: Diff of "select from list" fields shows change in key, not change in value
         o #1458814: File (and image) field support
         o #1418760: Optional setting to honour the display settings
         o #1347316: Selectable view mode for inline diffs and "Current revision" display view mode
         o #1458906: Improve performances (of existing 7.x-2.x field rendering)
         o #1424162: Diff in Taxonomy term description
         o #1211282: Image diff support
     The following patches will be posted in the corresponding project queues once
     the 7.x-3.x branch is released:
         o #1595702 by Alan D., mbilbille: Support of field collection module
         o #1350604 by Alan D., johaziel: Datetime diff
         o (no issue) by Alan D.: Email field Diff support
         o (no issue) by Alan D.: Countries Diff support
         o (no issue) by Alan D.: Name field Diff support
         o (no issue) by Alan D.: Link field Diff support

     class _DiffOp_Copy extends _DiffOp {
       var $type = 'copy';
       function _DiffOp_Copy($orig, $closing = FALSE) {
       function __construct($orig, $closing = FALSE) {
         if (!is_array($closing)) {
           $closing = $orig;
+        }
-...
     class _DiffOp_Delete extends _DiffOp {
       var $type = 'delete';
       function _DiffOp_Delete($lines) {
       function __construct($lines) {
         $this->orig = $lines;
         $this->closing = FALSE;
+      }
-...
     class _DiffOp_Add extends _DiffOp {
       var $type = 'add';
       function _DiffOp_Add($lines) {
       function __construct($lines) {
         $this->closing = $lines;
         $this->orig = FALSE;
+      }
-...
     class _DiffOp_Change extends _DiffOp {
       var $type = 'change';
       function _DiffOp_Change($orig, $closing) {
       function __construct($orig, $closing) {
         $this->orig = $orig;
         $this->closing = $closing;
+      }
-...
           // Find deletes & adds.
           $delete = array();
           while ($xi < $n_from && $this->xchanged[$xi]) {
             $delete[] = $from_lines[$xi++];
             $_fl = $from_lines[$xi++];
             if (strlen($_fl)) {
               $delete[] = $_fl;
+            }
+          }
           $add = array();
           while ($yi < $n_to && $this->ychanged[$yi]) {
             $add[] = $to_lines[$yi++];
             $_tl = $to_lines[$yi++];
             if (strlen($_tl)) {
               $add[] = $_tl;
+            }
+          }
           if ($delete && $add) {
             $edits[] = new _DiffOp_Change($delete, $add);
-...
        *      (Typically these are lines from a file.)
        * @param $to_lines array An array of strings.
        */
       function Diff($from_lines, $to_lines) {
       function __construct($from_lines, $to_lines) {
         $eng = new _DiffEngine;
         $this->edits = $eng->diff($from_lines, $to_lines);
         //$this->_check($from_lines, $to_lines);
-...
        * @param $mapped_to_lines array This array should
        *  have the same number of elements as $to_lines.
        */
       function MappedDiff($from_lines, $to_lines, $mapped_from_lines, $mapped_to_lines) {
       function __construct($from_lines, $to_lines, $mapped_from_lines, $mapped_to_lines) {
         assert(sizeof($from_lines) == sizeof($mapped_from_lines));
         assert(sizeof($to_lines) == sizeof($mapped_to_lines));
         $this->Diff($mapped_from_lines, $mapped_to_lines);
         parent::__construct($mapped_from_lines, $mapped_to_lines);
         $xi = $yi = 0;
         for ($i = 0; $i < sizeof($this->edits); $i++) {
-...
      * @subpackage DifferenceEngine
      */
     class _HWLDF_WordAccumulator {
       function _HWLDF_WordAccumulator() {
       function __construct() {
         $this->_lines = array();
         $this->_line = '';
         $this->_group = '';
-...
         return 10000;
+      }
       function WordLevelDiff($orig_lines, $closing_lines) {
       function __construct($orig_lines, $closing_lines) {
         list($orig_words, $orig_stripped) = $this->_split($orig_lines);
         list($closing_words, $closing_stripped) = $this->_split($closing_lines);
         $this->MappedDiff($orig_words, $closing_words, $orig_stripped, $closing_stripped);
         parent::__construct($orig_words, $closing_words, $orig_stripped, $closing_stripped);
+      }
       function _split($lines) {
-...
         'offset' => array('x' => 0, 'y' => 0),
       );
       function DrupalDiffFormatter() {
       function __construct() {
         $this->leading_context_lines = variable_get('diff_context_lines_leading', 2);
         $this->trailing_context_lines = variable_get('diff_context_lines_trailing', 2);
+      }

     html.js .diff-js-hidden { display: none; }
     html.js .diff-js-hidden {
       display: none;
+    }
     /* Reset as many core themes as possible */
     table.diff {
-...
       border: 0 none;
       width: 98%;
       border-spacing: 5px;
       table-layout: fixed ;
       table-layout: fixed;
       border-collapse: separate;
+    }
     table.diff tr td:last-child {
-...
       border-spacing: 4px;
       padding: 4px 8px;
+    }
     table.diff tr, table.diff tr.even {
     table.diff tr,
     table.diff tr.even {
       background: none;
+    }
     table.diff tr th, table.diff tr th a, table.diff tr th a:hover {
     table.diff tr th,
     table.diff tr th a,
     table.diff tr th a:hover {
       color: inherit;
       font-weight: bold;
+    }
-...
       border-style: none;
       background: transparent;
+    }
     table.diff th a { display: inline; }
     table.diff th a {
       display: inline;
+    }
     /* Main theming */
     table.diff, td.diff-number {
       background-color: white
     table.diff,
     td.diff-number {
       background-color: white;
+    }
     table.diff td.diff-lineno {
       font-weight: bold
       font-weight: bold;
+    }
     table.diff td.diff-addedline, table.diff td.diff-deletedline, table.diff td.diff-context {
     table.diff td.diff-addedline,
     table.diff td.diff-deletedline,
     table.diff td.diff-context {
       font-size: 88%;
       vertical-align: top;
       white-space: -moz-pre-wrap;
       white-space: pre-wrap
       white-space: pre-wrap;
+    }
     table.diff td.diff-addedline, table.diff td.diff-deletedline {
     table.diff td.diff-addedline,
     table.diff td.diff-deletedline {
       border-style: solid;
       border-width: 1px 1px 1px 4px;
       border-radius: 0.33em
       border-radius: 0.33em;
+    }
     table.diff td.diff-context {
-...
+    }
     table.diff td.diff-deletedline {
       border-color: #ffe49c
       border-color: #ffe49c;
+    }
     .diffchange {
       font-weight: bold;
       text-decoration: none
       text-decoration: none;
+    }
     table.diff td.diff-addedline .diffchange, table.diff td.diff-deletedline .diffchange {
     table.diff td.diff-addedline .diffchange,
     table.diff td.diff-deletedline .diffchange {
       border-radius: 0.33em;
       padding: 0.25em 0
       padding: 0.25em 0;
+    }
     table.diff td.diff-addedline .diffchange {
       background: #d8ecff
       background: #d8ecff;
+    }
     table.diff td.diff-deletedline .diffchange {
       background: #feeec8
       background: #feeec8;
+    }
     table.diff table.diff td {
       padding: 0.33em 0.66em
       padding: 0.33em 0.66em;
+    }
     table.diff td.diff-marker {
       width: 2%;
       text-align: right;
       font-weight: bold;
       font-size: 1.25em
       font-size: 1.25em;
+    }
     table.diff col.diff-content {
       width: 48%
       width: 48%;
+    }
     table.diff table.diff td div {
       word-wrap: break-word;
       overflow: auto
       overflow: auto;
+    }
     td.diff-prevlink {
       text-align: left;
-...
     td.diff-nextlink {
       text-align: right;
+    }
     table.diff-revisions tr.revision-published td {
       background-color: #aaffaa;
+    }

     html.js .diff-js-hidden { display: none; }
     html.js .diff-js-hidden {
       display: none;
+    }
     /**
      * Inline diff metadata
      */
     .diff-inline-metadata {
       padding:4px;
       border:1px solid #ddd;
       background:#fff;
       margin:0px 0px 10px;
       padding: 4px;
       border: 1px solid #ddd;
       background: #fff;
       margin: 0 0 10px;
+    }
     .diff-inline-legend { font-size:11px; }
     .diff-inline-legend {
       font-size: 11px;
+    }
     .diff-inline-legend span,
     .diff-inline-legend label { margin-right:5px; }
     .diff-inline-legend label {
       margin-right: 5px;
+    }
     /**
      * Inline diff markup
      */
     span.diff-deleted { color:#ccc; }
     span.diff-deleted img { border: solid 2px #ccc; }
     span.diff-changed { background:#ffb; }
     span.diff-changed img { border:solid 2px #ffb; }
     span.diff-added { background:#cfc; }
     span.diff-added img { border: solid 2px #cfc; }
     span.diff-deleted {
       color: #ccc;
+    }
     span.diff-deleted img {
       border: solid 2px #ccc;
+    }
     span.diff-changed {
       background: #ffb;
+    }
     span.diff-changed img {
       border: solid 2px #ffb;
+    }
     span.diff-added {
       background: #cfc;
+    }
     span.diff-added img {
       border: solid 2px #cfc;
+    }
     /**
      * Traditional split diff theming
-...
       table-layout: fixed;
       width: 100%;
+    }
     table.diff tr.even, table.diff tr.odd {
     table.diff tr.even,
     table.diff tr.odd {
       background-color: inherit;
       border: none;
+    }
-...
     td.diff-nextlink {
       text-align: right;
+    }
     td.diff-section-title, div.diff-section-title {
     td.diff-section-title,
     div.diff-section-title {
       background-color: #f0f0ff;
       font-size: 0.83em;
       font-weight: bold;
-...
     table.diff td {
       padding: 0.1ex 0.4em;
+    }
     table.diff-revisions tr.revision-published td {
       background-color: #aaffaa;
+    }

         '#empty_option' => t('- None -'),
         '#description' => t('Alter the CSS used when displaying diff results.'),
       );
       $form['diff_default_state_node'] = array(
         '#type' => 'select',
         '#title' => t('Diff default state'),
         '#default_value' => variable_get('diff_default_state_node', 'raw'),
         '#options' => array(
           'raw' => t('HTML view'),
           'raw_plain' => t('Plain view'),
         ),
         '#empty_option' => t('- None -'),
         '#description' => t('Default display to show when viewing a diff, html tags in diffed result or as plain text.'),
       );
       $form['diff_radio_behavior'] = array(
         '#type' => 'select',
         '#title' => t('Diff radio behavior'),
-...
     function diff_admin_global_entity_settings($form, $form_state, $entity_type) {
       $entity_info = entity_get_info($entity_type);
       drupal_set_title(t('Diff settings for %entity_label entities', array('%entity_label' => $entity_info['label'])), PASS_THROUGH);
       if ($options = module_invoke_all('entity_diff_options', $entity_type)) {
         $form['diff_additional_options_' . $entity_type] = array(
           '#type' => 'checkboxes',
           '#title' => t('Property options'),
           '#default_value' => variable_get('diff_additional_options_' . $entity_type, array()),
           '#options' => $options,
         );
+      }
       else {
         $form['diff_additional_options_' . $entity_type] = array(
           '#type' => 'value',
           '#value' => array(),
         );
+      }
       $form['diff_show_header_' . $entity_type] = array(
         '#type' => 'checkbox',
         '#title' => t('Show entity label header'),
         '#title' => t('Show entity label row header'),
         '#default_value' => variable_get('diff_show_header_' . $entity_type, 1),
       );
       if (user_access('administer permissions')) {
         $admin_link = l(t('View the administration theme'), 'admin/people/permissions', array('fragment' => 'edit-view-the-administration-theme'));
+      }
       else {
         $admin_link = t('View the administration theme');
+      }
       $form['diff_admin_path_' . $entity_type] = array(
         '#type' => 'checkbox',
         '#title' => t('Treat diff pages as administrative'),
         '#description' => t('Diff pages are treated as administrative pages by default, although it is up to each module to enforce this and to implement this optional setting.'),
         '#title' => t('Use administration theme'),
         '#description' => t('This option will enable users with the <em>!link</em> permission to use the admin theme when doing comparisons.', array('!link' => $admin_link)),
         '#default_value' => variable_get('diff_admin_path_' . $entity_type, 1),
       );
       $form['diff_default_state_' . $entity_type] = array(
         '#type' => 'select',
         '#title' => t('Diff default state'),
         '#default_value' => variable_get('diff_default_state_' . $entity_type, 'raw'),
         '#options' => array(
           'raw' => t('HTML view'),
           'raw_plain' => t('Plain view'),
         ),
         '#empty_option' => t('- None -'),
         '#description' => t('Default display to show when viewing a diff, html tags in diffed result or as plain text.'),
       );
       return system_settings_form($form);
+    }

      */
     /**
      * Allow modules to provide a comparison about entities.
      * Allow modules to provide a comparison about entity properties.
+     *
      * @param object $old_entity
      *   The older entity revision.
+     *
      * @param object $new_entity
      *   The newer entity revision.
+     *
      * @param array $context
      *   An associative array containing:
      *   - entity_type: The entity type; e.g., 'node' or 'user'.
      *   - view_mode: The view mode to use. Defaults to FALSE.
      *   - old_entity: The older entity.
      *   - new_entity: The newer entity.
      *   - view_mode: The view mode to use. Defaults to FALSE. If no view mode is
      *                given, the recommended fallback view mode is 'default'.
      *   - states: An array of view states. These could be one of:
      *     - raw: The raw value of the diff, the classic 7.x-2.x view.
      *     - rendered: The rendered HTML as determined by the view mode. Only
      *                 return markup for this state if the value is normally shown
      *                 by this view mode. The user will most likely be able to see
      *                 the raw or raw_plain state, so this is optional.
+     *
      *                 The rendering state is a work in progress.
+     *
      *     Conditionally, you can get these states, but setting these will override
      *     the user selectable markdown method.
+     *
      *     - raw_plain: As raw, but text should be markdowned.
      *     - rendered_plain: As rendered, but text should be markdowned.
+     *
      * @return array
      *   An associative array of values keyed by the entity property.
+     *
      * @todo
      *   Investiagate options and document these.
      *   This is effectively an unnested Form API-like structure.
+     *
      *   States are returned as follows:
+     *
      *   $results['line'] = array(
      *     '#name' => t('Line'),
      *     '#states' => array(
      *       'raw' => array(
      *         '#old' => '<p class="line">This was the old line number [tag].</p>',
      *         '#new' => '<p class="line">This is the new line [tag].</p>',
      *       ),
      *       'rendered' => array(
      *         '#old' => '<p class="line">This was the old line number <span class="line-number">57</span>.</p>',
      *         '#new' => '<p class="line">This is the new line <span class="line-number">57</span>.</p>',
      *       ),
      *     ),
      *   );
+     *
      *   For backwards compatibility, no changes are required to support states,
      *   but it is recommended to provide a better UI for end users.
+     *
      *   For example, the following example is equivalent to returning the raw
      *   state from the example above.
+     *
      *   $results['line'] = array(
      *     '#name' => t('Line'),
      *     '#old' => '<p class="line">This was the old line number [tag].</p>',
      *     '#new' => '<p class="line">This is the new line [tag].</p>',
      *   );
      */
     function hook_entity_diff($old_entity, $new_entity, $context) {
       $results = array();
       if ($context['entity_type'] == 'node') {
         $type = node_type_get_type($new_entity);
         $result['title'] = array(
         $results['title'] = array(
           '#name' => $type->title_label,
           '#old' => array($old_entity->title),
           '#new' => array($new_entity->title),
-...
           ),
         );
+      }
       return $results;
+    }
     /**
-...
+     *
      * @see hook_entity_diff()
      */
     function hook_entity_diff_alter($entity_diffs, $context) {
     function hook_entity_diff_alter(&$entity_diffs, $context) {
+    }
     /**

     html.js .diff-js-hidden { display:none; }
     html.js .diff-js-hidden {
       display:none;
+    }
     /**
      * Inline diff metadata
      */
     .diff-inline-metadata {
       padding:4px;
       border:1px solid #ddd;
       background:#fff;
       margin:0px 0px 10px;
+      }
     .diff-inline-legend { font-size:11px; }
       padding: 4px;
       border: 1px solid #ddd;
       background: #fff;
       margin: 0 0 10px;
+    }
     .diff-inline-legend {
       font-size: 11px;
+    }
     .diff-inline-legend span,
     .diff-inline-legend label { margin-right:5px; }
     .diff-inline-legend label {
       margin-right: 5px;
+    }
     /**
      * Inline diff markup
      */
     span.diff-deleted { color:#ccc; }
     span.diff-deleted img { border: solid 2px #ccc; }
     span.diff-changed { background:#ffb; }
     span.diff-changed img { border:solid 2px #ffb; }
     span.diff-added { background:#cfc; }
     span.diff-added img { border: solid 2px #cfc; }
     span.diff-deleted {
       color: #ccc;
+    }
     span.diff-deleted img {
       border: solid 2px #ccc;
+    }
     span.diff-changed {
       background: #ffb;
+    }
     span.diff-changed img {
       border: solid 2px #ffb;
+    }
     span.diff-added {
       background: #cfc;
+    }
     span.diff-added img {
       border: solid 2px #cfc;
+    }
     /**
      * Traditional split diff theming
-...
       table-layout: fixed;
       width: 100%;
+    }
     table.diff tr.even, table.diff tr.odd {
     table.diff tr.even,
     table.diff tr.odd {
       background-color: inherit;
       border: none;
+    }
-...
     td.diff-nextlink {
       text-align: right;
+    }
     td.diff-section-title, div.diff-section-title {
     td.diff-section-title,
     div.diff-section-title {
       background-color: #f0f0ff;
       font-size: 0.83em;
       font-weight: bold;

+     *
      * This manually invokes hook_diff() to avoid a function name clash with the
      * PHP 5 (>= 5.3.0) date_diff() function or the Dates modules implementation.
+     *
      * @param object $old_entity
      *   The older node revision.
      * @param object $new_entity
      *   The newer node revision.
      * @param array $context
      *   An associative array containing:
      *   - entity_type: The entity type; e.g., 'node' or 'user'.
      *   - old_entity: The older entity.
      *   - new_entity: The newer entity.
      *   - view_mode: The view mode to use. Defaults to FALSE.
      */
     function diff_entity_diff($old_entity, $new_entity, $context) {
       $return = array();
-...
      *   - old_entity: The older entity.
      *   - new_entity: The newer entity.
      *   - view_mode: The view mode to use. Defaults to FALSE.
      * @param string $default_langcode
      *   (optional) Language code to force comparison in.
+     *
      * @return array
      *   An associative array of values keyed by the field name and delta value.
      */
     function diff_entity_fields_diff($old_entity, $new_entity, $context) {
     function diff_entity_fields_diff($old_entity, $new_entity, $context, $default_langcode = NULL) {
       $result = array();
       $entity_type = $context['entity_type'];
-...
       $field_context = $context;
       $actual_mode = FALSE;
       list(,, $bundle_name) = entity_extract_ids($entity_type, $new_entity);
       list(, , $bundle_name) = entity_extract_ids($entity_type, $new_entity);
       $instances = field_info_instances($entity_type, $bundle_name);
       // Some fields piggy back the display settings, so we need to fake these by
-...
         // We provide a loose check on the field access.
         if (field_access('view', $field, $entity_type) || field_access('edit', $field, $entity_type)) {
           $langcode = field_language($entity_type, $new_entity, $field_name);
           $langcode = $default_langcode ? $default_langcode : field_language($entity_type, $new_entity, $field_name);
           $field_context['language'] = $langcode;
           $field_context['field'] = $field;
-...
             $func = 'diff_field_diff_view';
+          }
           // Copy the static ID cache to ensure this is the same for each comparison.
           $original_html_ids = drupal_static('drupal_html_id');
           $html_ids = &drupal_static('drupal_html_id');
           // These callbacks should be independent of revision.
           $old_context = $field_context;
           $old_context['entity'] = $old_entity;
           $old_values = $func($old_items, $old_context);
           // Restores the ID cache to the original.
           $html_ids = $original_html_ids;
           $new_context = $field_context;
           $new_context['entity'] = $new_entity;
           $new_values = $func($new_items, $new_context);
-...
      *   An array of strings representing the value, keyed by delta index.
      */
     function diff_field_diff_view($items, $context) {
       // Prevent unnecessary rendering of the field. This also prevents issues
       // where field_view_field() will use a language fallback for display that
       // may not match the requested diff comparison language.
       if (!$items) {
         return array();
+      }
       $diff_items = array();
        $entity = clone $context['entity'];
        $langcode = field_language($context['entity_type'], $entity, $context['field']['field_name']);
        $view_mode = empty($context['view_mode']) ? 'diff_standard' : $context['view_mode'];
        $element = field_view_field($context['entity_type'], $entity, $context['field']['field_name'], $view_mode, $langcode);
        foreach (element_children($element) as $delta) {
          $diff_items[$delta] = drupal_render($element[$delta]);
+       }
       $entity = clone $context['entity'];
       $langcode = field_language($context['entity_type'], $entity, $context['field']['field_name']);
       $view_mode = empty($context['view_mode']) ? 'diff_standard' : $context['view_mode'];
       $element = field_view_field($context['entity_type'], $entity, $context['field']['field_name'], $view_mode, $langcode);
       foreach (element_children($element) as $delta) {
         $diff_items[$delta] = drupal_render($element[$delta]);
+      }
       return $diff_items;
+    }
     /**
      * Helper function to get the settings for a given field or formatter.
+     *
      * @param array $context
      * @param array $field_context
      *   This will get the settings for a field.
      *   - field (required): The field that the items belong to.
      *   - entity: The entity that we are looking up.
-...
         ),
       );
       /*
     This would be cool, but to do anything else than inline with the text appears
     to be very hard, requiring a refactoring of both the modules API but also the
     DiffFormatter and Diff classes. Diff 8.x-4.x maybe.
       $subform['show_delta'] = array(
         '#type' => 'checkbox',
         '#title' => t('Show delta values'),
         '#default_value' => $settings['show_delta'],
       );
       $subform['delta_format'] = array(
         '#type' => 'radios',
         '#title' => t('Delta insertion method'),
         '#default_value' => $settings['delta_format'],
         '#options' => array(
           'inline' => t('Prefix to item'),
           'row' => t('Individual row'),
         ),
         '#states' => array(
           'invisible' => array(
             "input[id$='show-delta']" => array('checked' => FALSE),
           ),
         ),
       );
       */
+    }
     /**
-...
         'markdown' => function_exists($func) ? '' : 'drupal_html_to_text',
         'line_counter' => '',
         'show_header' => 1,
         // Can we? This seems too hard to track in the DiffFormatter as all we
         // have is a string or an array of strings.
         //'show_delta' => 0,
         //'delta_format' => 'row',
       );
       return $settings;
+    }

     name = Diff
     description = Show differences between content revisions.
     core = 7.x
     configure = admin/config/content/diff
     files[] = DiffEngine.php
     ; Information added by drupal.org packaging script on 2012-11-13
     version = "7.x-3.2"
     ; Information added by Drupal.org packaging script on 2016-12-20
     version = "7.x-3.3"
     core = "7.x"
     project = "diff"
     datestamp = "1352784357"
     datestamp = "1482211686"

      * Provides uninstallation functions.
      */
     /**
      * Implements hook_install().
      */
     function diff_install() {
       user_role_grant_permissions(DRUPAL_ANONYMOUS_RID, array('diff view changes'));
       user_role_grant_permissions(DRUPAL_AUTHENTICATED_RID, array('diff view changes'));
+    }
     /**
      * Implements hook_uninstall().
      */
-...
         'diff_view_mode_',
         'diff_admin_path_',
         'diff_default_state_',
         'diff_additional_options_',
       );
       foreach ($prefixes as $prefix) {
         db_delete('variable')
-...
+      }
+    }
     /**
      * Removed diff_update_7301().
      */
     /**
      * Removed diff_update_7302().
      */
     /**
      * Renames some internal settings names.
      */
     function diff_update_7303() {
       // Get current values
       // Get current values.
       $radio = variable_get('diff_script_revisioning', 'simple');
       $leading = variable_get('diff_leading_context_lines', 2);
       $trailing = variable_get('diff_trailing_context_lines', 2);
       // Create new variable names
       // Create new variable names.
       variable_set('diff_radio_behavior', $radio);
       variable_set('diff_context_lines_leading', $leading);
       variable_set('diff_context_lines_trailing', $trailing);
       // Delete old variables
       // Delete old variables.
       variable_del('diff_script_revisioning');
       variable_del('diff_leading_context_lines');
       variable_del('diff_trailing_context_lines');
-...
       // This is now always applied to text fields.
       variable_del('diff_normalise_text');
       // Merge the content type settings for the inline diff block into a single variable.
       // diff_update_7300() - show_diff_inline_TYPE to diff_show_diff_inline_node_TYPE
       // Merge the content type settings for the inline diff block into a single
       // variable.
       $node_types = array_keys(node_type_get_types());
       $enabled_types = array();
       foreach ($node_types as $node_type) {
-...
           ->condition('name', db_like('diff_view_mode_inline_') . '%', 'LIKE')
           ->execute();
+    }
     /**
      * Sets the optional additional node properties to render so that the title
      * still shows by default when doing node comparisons.
      */
     function diff_update_7306() {
       variable_set('diff_additional_options_node', array('title' => 'title'));
+    }
     /**
      * Grants access to the Diff "View Changes" button permission to all users.
      */
     function diff_update_7307() {
       user_role_grant_permissions(DRUPAL_ANONYMOUS_RID, array('diff view changes'));
       user_role_grant_permissions(DRUPAL_AUTHENTICATED_RID, array('diff view changes'));
+    }

         case 'admin/help#diff':
           $output = '<p>' . t('The Diff module replaces the normal <em>Revisions</em> node tab. Diff enhances the listing of revisions with an option to view the differences between any two content revisions. Access to this feature is controlled with the <em>View revisions</em> permission. The feature can be disabled for an entire content type on the content type configuration page. Diff also provides an optional <em>View changes</em> button while editing a node.') . '</p>';
           return $output;
         case 'node/%/revisions/%/view':
           // The translated strings should match node_help('node/%/revisions').
           return '<p>' . t('Revisions allow you to track differences between multiple versions of your content, and revert back to older versions.') . '</p>';
         case 'node/%/revisions/view/%/%':
           return '<p>' . t('Comparing two revisions:') . '</p>';
+      }
+    }
-...
         'page callback' => 'diff_latest',
         'page arguments' => array(1),
         'type' => MENU_LOCAL_TASK,
         'access callback' => 'diff_node_revision_access',
         'access arguments' => array(1),
         'access arguments' => array('access content'),
         'tab_parent' => 'node/%/revisions/view',
         'file' => 'diff.pages.inc',
       );
-...
       );
       $items['admin/config/content/diff/entities/node'] = array(
         'title' => 'Node',
         'title' => 'Nodes',
         'description' => 'Node comparison settings.',
         'type' => MENU_DEFAULT_LOCAL_TASK,
         'weight' => -10,
       );
       $items['admin/config/content/diff/entities/user'] = array(
         'title' => 'Users',
         'description' => 'User diff settings.',
         'file' => 'diff.admin.inc',
         'page callback' => 'drupal_get_form',
         'page arguments' => array('diff_admin_global_entity_settings', 'user'),
         'access arguments' => array('administer site configuration'),
         'type' => MENU_LOCAL_TASK,
       );
       return $items;
+    }
-...
       return $may_revision_this_type && _node_revision_access($node, $op);
+    }
     /**
      * Implements hook_permission().
      */
     function diff_permission() {
       return array(
         'diff view changes' => array(
           'title' => t('Access %view button', array('%view' => t('View changes'))),
           'description' => t('Controls access to the %view button when editing content.', array('%view' => t('View changes'))),
         ),
       );
+    }
     /**
      * Implements hook_hook_info().
      */
-...
+      }
+    }
     /**
      * Returns a list of all the existing revision numbers.
+     *
      * Clone of node_revision_list() with revision status included. This would be
      * an additional join in Drupal 8.x to the {node_field_revision} table.
+     *
      * @param object $node
      *   The node object.
+     *
      * @return array
      *   An associative array keyed by node revision number.
      */
     function diff_node_revision_list($node) {
       $revisions = array();
       $result = db_query('SELECT r.vid, r.title, r.log, r.uid, n.vid AS current_vid, r.status AS status, r.timestamp, u.name FROM {node_revision} r LEFT JOIN {node} n ON n.vid = r.vid INNER JOIN {users} u ON u.uid = r.uid WHERE r.nid = :nid ORDER BY r.vid DESC', array(':nid' => $node->nid));
       foreach ($result as $revision) {
         $revisions[$revision->vid] = $revision;
+      }
       return $revisions;
+    }
     /**
      * Implements hook_block_info().
      */
-...
         $enabled_types = variable_get('diff_show_diff_inline_node_bundles', array());
         if (!empty($enabled_types[$node->type])) {
           $block = array();
           $revisions = node_revision_list($node);
           $revisions = diff_node_revision_list($node);
           if (count($revisions) > 1) {
             $block['subject'] = t('Highlight changes');
             $block['content'] = drupal_get_form('diff_inline_form', $node, $revisions);
-...
      */
     function diff_node_view_alter(&$build) {
       $node = $build['#node'];
       if (user_access('view revisions') && in_array($node->type, variable_get('diff_show_diff_inline_node_bundles', array()))) {
       if (user_access('view revisions') && in_array($node->type, variable_get('diff_show_diff_inline_node_bundles', array()), TRUE)) {
         // Ugly but cheap way to check that we are viewing a node's revision page.
         if (arg(2) === 'revisions' && arg(3) === $node->vid) {
           module_load_include('inc', 'diff', 'diff.pages');
-...
     function diff_form_node_form_alter(&$form, $form_state) {
       // Add a 'View changes' button on the node edit form.
       $node = $form['#node'];
       if (variable_get('diff_show_preview_changes_node_' . $node->type, TRUE) && !empty($node->nid)) {
       if (variable_get('diff_show_preview_changes_node_' . $node->type, TRUE)
           && user_access('diff view changes')
           && !empty($node->nid)) {
         $form['actions']['preview_changes'] = array(
           '#type' => 'submit',
           '#value' => t('View changes'),
-...
           '#title' => t('Show <em>View changes</em> button on node edit form'),
           '#weight' => 10,
           '#default_value' => variable_get('diff_show_preview_changes_node_' . $type->type, TRUE),
           '#description' => t('You can refine access using the "!perm" permission.', array(
             '!perm' => t('Access %view button', array('%view' => t('View changes'))),
           )),
         );
         $form['diff']['diff_enable_revisions_page_node'] = array(
           '#type' => 'checkbox',
-...
       $changes = theme('table__diff__preview', array(
         'header' => $header,
         'rows' => $rows,
         'attributes' => array('class' => 'diff'),
         'attributes' => array('class' => array('diff')),
         'colgroups' => _diff_default_cols(),
         'sticky' => FALSE,
       ));
-...
       $form_state['rebuild'] = TRUE;
+    }
     /**
      * Implementation of hook_features_pipe_COMPONENT_alter().
      */
     function diff_features_pipe_node_alter(&$pipe, $data, $export) {
       if (!empty($data)) {
         $variables = array(
           'diff_show_preview_changes_node',
           'diff_enable_revisions_page_node',
           'diff_view_mode_preview_node',
         );
         foreach ($data as $node_type) {
           foreach ($variables as $variable_name) {
             $pipe['variable'][] = $variable_name . '_' . $node_type;
+          }
+        }
+      }
+    }
     /**
      * Implements hook_theme().
      */
-...
      *   The source string to compare from.
      * @param string $b
      *   The target string to compare to.
      * @param boolean $show_header
      * @param bool $show_header
      *   Display diff context headers. For example, "Line x".
      * @param array $line_stats
      *   This structure tracks line numbers across multiple calls to DiffFormatter.
-...
+      }
       return $attachments;
+    }
     /**
      * Implements hook_entity_diff() on behalf of the Node module.
      */
     function node_entity_diff($old_node, $new_node, $context) {
       $result = array();
       if ($context['entity_type'] == 'node') {
         module_load_include('inc', 'diff', 'includes/node');
         $options = variable_get('diff_additional_options_node', array('title' => 'title'));
         foreach (node_entity_diff_options('node') as $key => $option_label) {
           if (!empty($options[$key])) {
             $func = '_node_entity_diff_additional_options_' . $key;
             $result[$key] = $func($old_node, $new_node, $context);
+          }
+        }
+      }
       return $result;
+    }
     /**
      * Implements hook_entity_diff_options() on behalf of the Node module.
      */
     function node_entity_diff_options($entity_type) {
       if ($entity_type == 'node') {
         $options = array(
           'title' => t('Title field'),
           // Author field is either the owner or revision creator, neither capture
           // a change in the author field.
           'author' => t('Author'),
           'revision_author' => t('Revision author'),
           'type' => t('Node type'),
           'publishing_flags' => t('Publishing options'),
           // More fields that currently can not be tracked.
           'created' => t('Created date'),
           'changed' => t('Updated date'),
           'revision_timestamp' => t('Revision timestamp'),
         );
         if (module_exists('comment')) {
           $options['comment'] = t('Comment setting');
+        }
         return $options;
+      }
+    }
     /**
      * Implements hook_entity_diff() on behalf of the User module.
      */
     function user_entity_diff($old_user, $new_user, $context) {
       $result = array();
       if ($context['entity_type'] == 'user') {
         module_load_include('inc', 'diff', 'includes/user');
         $options = variable_get('diff_additional_options_user', array(
           'name' => 'name',
           'mail' => 'mail',
           'status' => 'status',
         ));
         foreach (user_entity_diff_options('user') as $key => $option_label) {
           if (!empty($options[$key])) {
             $func = '_user_entity_diff_additional_options_' . $key;
             $result[$key] = $func($old_user, $new_user, $context);
+          }
+        }
+      }
       return $result;
+    }
     /**
      * Implements hook_entity_diff_options() on behalf of the User module.
      */
     function user_entity_diff_options($entity_type) {
       if ($entity_type == 'user') {
         $options = array(
           'name' => t('Username'),
           'mail' => t('E-mail address'),
           'roles' => t('Roles'),
           'status' => t('Status'),
           'timezone' => t('Time zone'),
           'password' => t('Password Hash'),
         );
         return $options;
+      }
+    }

      */
     function diff_latest($node) {
       $revisions = node_revision_list($node);
       if (count($revisions) < 2 || !diff_node_revision_access($node, 'view')) {
         drupal_goto('node/' . $node->nid);
+      }
       $new = array_shift($revisions);
       $old = array_shift($revisions);
       drupal_goto("node/{$node->nid}/revisions/view/{$old->vid}/{$new->vid}");
-...
         '#value' => $node->nid,
       );
       $revision_list = node_revision_list($node);
       $revision_list = diff_node_revision_list($node);
       $revision_count = count($revision_list);
       if (count($revision_list) > REVISION_LIST_SIZE) {
       if ($revision_count > REVISION_LIST_SIZE) {
         // If the list of revisions is longer than the number shown on one page
         // split the array.
         $page = isset($_GET['page']) ? $_GET['page'] : '0';
         $revision_chunks = array_chunk(node_revision_list($node), REVISION_LIST_SIZE);
         $revision_chunks = array_chunk($revision_list, REVISION_LIST_SIZE);
         $revisions = $revision_chunks[$page];
         // Set up global pager variables as would 'pager_query' do.
         // These variables are then used in the theme('pager') call later.
         global $pager_page_array, $pager_total, $pager_total_items;
         $pager_total_items[0] = count($revision_list);
         $pager_total[0] = ceil(count($revision_list) / REVISION_LIST_SIZE);
         $pager_total_items[0] = $revision_count;
         $pager_total[0] = ceil($revision_count / REVISION_LIST_SIZE);
         $pager_page_array[0] = max(0, min($page, ((int) $pager_total[0]) - 1));
+      }
       else {
-...
             '#markup' => t('!date by !username', array(
               '!date' => l(format_date($revision->timestamp, 'small'), "node/$node->nid"),
               '!username' => theme('username', array('account' => $revision)))) . $revision_log,
             '#revision' => $revision,
           );
+        }
         else {
-...
               '!date' => $diff_date,
               '!username' => theme('username', array('account' => $revision)))
             ) . $revision_log,
             '#revision' => $revision,
           );
           if ($revert_permission) {
             $operations[] = array(
-...
       $form['submit'] = array('#type' => 'submit', '#value' => t('Compare'));
       if (count($revision_list) > REVISION_LIST_SIZE) {
       if ($revision_count > REVISION_LIST_SIZE) {
         $form['#suffix'] = theme('pager');
+      }
       $form['#attached'] = diff_build_attachments(TRUE);
       return $form;
+    }
     /**
      * Submit code for input form to select two revisions.
      */
     function diff_node_revisions_submit($form, &$form_state) {
       // The ids are ordered so the old revision is always on the left.
       $old_vid = min($form_state['values']['old'], $form_state['values']['new']);
       $new_vid = max($form_state['values']['old'], $form_state['values']['new']);
       $form_state['redirect'] = 'node/' . $form_state['values']['nid'] . '/revisions/view/' . $old_vid . '/' . $new_vid;
+    }
     /**
      * Validation for input form to select two revisions.
      */
-...
+      }
+    }
     /**
      * Submit code for input form to select two revisions.
      */
     function diff_node_revisions_submit($form, &$form_state) {
       // The ids are ordered so the old revision is always on the left.
       $old_vid = min($form_state['values']['old'], $form_state['values']['new']);
       $new_vid = max($form_state['values']['old'], $form_state['values']['new']);
       if (isset($_GET['destination'])) {
         unset($_GET['destination']);
+      }
       $form_state['redirect'] = 'node/' . $form_state['values']['nid'] . '/revisions/view/' . $old_vid . '/' . $new_vid;
+    }
     /**
      * Create a comparison for the node between versions 'old_vid' and 'new_vid'.
+     *
      * @param object $node
      *   Node on which to perform comparison
      * @param integer $old_vid
      *   Node on which to perform comparison.
      * @param int $old_vid
      *   Version ID of the old revision.
      * @param integer $new_vid
      * @param int $new_vid
      *   Version ID of the new revision.
      */
     function diff_diffs_show($node, $old_vid, $new_vid, $state = NULL) {
-...
       $default_state = variable_get('diff_default_state_node', 'raw');
       if (empty($state)) {
       	$state = $default_state;
         $state = $default_state;
+      }
       $state = str_replace('-', '_', $state);
       if (!array_key_exists($state, diff_available_states())) {
-...
+        }
         $build['diff_preview']['header']['#markup'] = $header;
         // Don't include node links or comments when viewing the diff.
         $build['diff_preview']['content'] = node_view($new_node, $view_mode);
         $build['diff_preview']['content'] = function_exists('entity_view') ? entity_view('node', array($new_node), $view_mode) : node_view($new_node, $view_mode);
         if (isset($build['diff_preview']['content']['links'])) {
           unset($build['diff_preview']['content']['links']);
+        }
-...
+    }
     /**
      * Creates an array of rows which represent the difference between nodes.
      * Creates an array of rows which represent the difference between two entities.
+     *
      * @param object $old_node
      *   Node for comparison which will be displayed on the left side.
      * @param object $new_node
      *   Node for comparison which will be displayed on the right side.
      * @param boolean $state
      *   The state to render for the diff.
      * @param object $left_entity
      *   Entity for comparison which will be displayed on the left side.
      * @param object $right_entity
      *   Entity for comparison which will be displayed on the right side.
      * @param array $context
      *   The context used to render the diff.
      */
     function _diff_body_rows($old_node, $new_node, $state = 'raw') {
     function diff_entity_body_rows($entity_type, $left_entity, $right_entity, $context = array()) {
       // This is an unique index only, so no need for drupal_static().
       static $table_row_counter = 0;
       if ($theme = variable_get('diff_theme', 'default')) {
         drupal_add_css(drupal_get_path('module', 'diff') . "/css/diff.{$theme}.css");
+      }
       module_load_include('inc', 'diff', 'includes/node');
       $rows = array();
       $any_visible_change = FALSE;
       $context = array(
         'entity_type' => 'node',
         'states' => array($state),
       $context += array(

Projet

Général

Profil

Club Drupal

Révision 661d64c9

Ajouté par Assos Assos il y a plus de 7 ans