class Diff in Zircon Profile 8

Class representing a 'diff' between two sequences of strings. @todo document @subpackage DifferenceEngine

Copied from https://www.drupal.org/project/diff which was based PHP diff engine for phpwiki. (Taken from phpwiki-1.3.3) The original code in phpwiki was copyright (C) 2000, 2001 Geoffrey T. Dairiki <[e-mail]> and licensed under GPL.

Hierarchy

• class \Drupal\Component\Diff\Diff

2 files declare their use of Diff

AssertConfigTrait.php in core/tests/Drupal/KernelTests/AssertConfigTrait.php

Contains \Drupal\KernelTests\AssertConfigTrait.

ConfigManager.php in core/lib/Drupal/Core/Config/ConfigManager.php

Contains \Drupal\Core\Config\ConfigManager.

File

core/lib/Drupal/Component/Diff/Diff.php, line 22

Contains \Drupal\Component\Diff\Diff.

Namespace

Drupal\Component\Diff

class Diff {

  /**
   * The list of differences as an array of diff operations.
   *
   * @var \Drupal\Component\Diff\Engine\DiffOp[]
   */
  protected $edits;

  /**
   * Constructor.
   * Computes diff between sequences of strings.
   *
   * @param $from_lines array An array of strings.
   *      (Typically these are lines from a file.)
   * @param $to_lines array An array of strings.
   */
  public function __construct($from_lines, $to_lines) {
    $eng = new DiffEngine();
    $this->edits = $eng
      ->diff($from_lines, $to_lines);

    //$this->_check($from_lines, $to_lines);
  }

  /**
   * Compute reversed Diff.
   *
   * SYNOPSIS:
   *
   *  $diff = new Diff($lines1, $lines2);
   *  $rev = $diff->reverse();
   * @return object A Diff object representing the inverse of the
   *          original diff.
   */
  public function reverse() {
    $rev = $this;
    $rev->edits = array();
    foreach ($this->edits as $edit) {
      $rev->edits[] = $edit
        ->reverse();
    }
    return $rev;
  }

  /**
   * Check for empty diff.
   *
   * @return bool True iff two sequences were identical.
   */
  public function isEmpty() {
    foreach ($this->edits as $edit) {
      if ($edit->type != 'copy') {
        return FALSE;
      }
    }
    return TRUE;
  }

  /**
   * Compute the length of the Longest Common Subsequence (LCS).
   *
   * This is mostly for diagnostic purposed.
   *
   * @return int The length of the LCS.
   */
  public function lcs() {
    $lcs = 0;
    foreach ($this->edits as $edit) {
      if ($edit->type == 'copy') {
        $lcs += sizeof($edit->orig);
      }
    }
    return $lcs;
  }

  /**
   * Gets the original set of lines.
   *
   * This reconstructs the $from_lines parameter passed to the
   * constructor.
   *
   * @return array The original sequence of strings.
   */
  public function orig() {
    $lines = array();
    foreach ($this->edits as $edit) {
      if ($edit->orig) {
        array_splice($lines, sizeof($lines), 0, $edit->orig);
      }
    }
    return $lines;
  }

  /**
   * Gets the closing set of lines.
   *
   * This reconstructs the $to_lines parameter passed to the
   * constructor.
   *
   * @return array The sequence of strings.
   */
  public function closing() {
    $lines = array();
    foreach ($this->edits as $edit) {
      if ($edit->closing) {
        array_splice($lines, sizeof($lines), 0, $edit->closing);
      }
    }
    return $lines;
  }

  /**
   * Check a Diff for validity.
   *
   * This is here only for debugging purposes.
   */
  public function check($from_lines, $to_lines) {
    if (serialize($from_lines) != serialize($this
      ->orig())) {
      trigger_error("Reconstructed original doesn't match", E_USER_ERROR);
    }
    if (serialize($to_lines) != serialize($this
      ->closing())) {
      trigger_error("Reconstructed closing doesn't match", E_USER_ERROR);
    }
    $rev = $this
      ->reverse();
    if (serialize($to_lines) != serialize($rev
      ->orig())) {
      trigger_error("Reversed original doesn't match", E_USER_ERROR);
    }
    if (serialize($from_lines) != serialize($rev
      ->closing())) {
      trigger_error("Reversed closing doesn't match", E_USER_ERROR);
    }
    $prevtype = 'none';
    foreach ($this->edits as $edit) {
      if ($prevtype == $edit->type) {
        trigger_error("Edit sequence is non-optimal", E_USER_ERROR);
      }
      $prevtype = $edit->type;
    }
    $lcs = $this
      ->lcs();
    trigger_error('Diff okay: LCS = ' . $lcs, E_USER_NOTICE);
  }

  /**
   * Gets the list of differences as an array of diff operations.
   *
   * @return \Drupal\Component\Diff\Engine\DiffOp[]
   *   The list of differences as an array of diff operations.
   */
  public function getEdits() {
    return $this->edits;
  }

}

Members

Name	Modifiers	Type	Description	Overrides
Diff::$edits	protected	property	The list of differences as an array of diff operations.
Diff::check	public	function	Check a Diff for validity.
Diff::closing	public	function	Gets the closing set of lines.	1
Diff::getEdits	public	function	Gets the list of differences as an array of diff operations.
Diff::isEmpty	public	function	Check for empty diff.
Diff::lcs	public	function	Compute the length of the Longest Common Subsequence (LCS).
Diff::orig	public	function	Gets the original set of lines.	1
Diff::reverse	public	function	Compute reversed Diff.
Diff::__construct	public	function	Constructor. Computes diff between sequences of strings.	1