DiffOpOutputBuilder.php

<?php declare(strict_types=1);

namespace Drupal\Component\Diff;

use Drupal\Component\Diff\Engine\DiffOp;
use Drupal\Component\Diff\Engine\DiffOpAdd;
use Drupal\Component\Diff\Engine\DiffOpChange;
use Drupal\Component\Diff\Engine\DiffOpCopy;
use Drupal\Component\Diff\Engine\DiffOpDelete;
use SebastianBergmann\Diff\Differ;
use SebastianBergmann\Diff\Output\DiffOutputBuilderInterface;

/**
 * Returns a diff as an array of DiffOp operations.
 */
final class DiffOpOutputBuilder implements DiffOutputBuilderInterface {

  /**
   * A constant to manage removal+addition as a single operation.
   */
  private const CHANGED = 999;

  /**
   * {@inheritdoc}
   */
  public function getDiff(array $diff): string {
    return serialize($this->toOpsArray($diff));
  }

  /**
   * Converts the output of Differ to an array of DiffOp* value objects.
   *
   * @param array $diff
   *   The array output of Differ::diffToArray().
   *
   * @return \Drupal\Component\Diff\Engine\DiffOp[]
   *   An array of DiffOp* value objects.
   */
  public function toOpsArray(array $diff): array {
    $ops = [];
    $hunkMode = NULL;
    $hunkSource = [];
    $hunkTarget = [];

    for ($i = 0; $i < count($diff); $i++) {

      // Handle a sequence of removals + additions as a sequence of changes, and
      // manages the tail if required.
      if ($diff[$i][1] === Differ::REMOVED) {
        if ($hunkMode !== NULL) {
          $ops[] = $this->hunkOp($hunkMode, $hunkSource, $hunkTarget);
          $hunkSource = [];
          $hunkTarget = [];
        }
        for ($n = $i; $n < count($diff) && $diff[$n][1] === Differ::REMOVED; $n++) {
          $hunkSource[] = $diff[$n][0];
        }
        for (; $n < count($diff) && $diff[$n][1] === Differ::ADDED; $n++) {
          $hunkTarget[] = $diff[$n][0];
        }
        if (count($hunkTarget) === 0) {
          $ops[] = $this->hunkOp(Differ::REMOVED, $hunkSource, $hunkTarget);
        }
        else {
          $ops[] = $this->hunkOp(self::CHANGED, $hunkSource, $hunkTarget);
        }
        $hunkMode = NULL;
        $hunkSource = [];
        $hunkTarget = [];
        $i = $n - 1;
        continue;
      }

      // When here, we are adding or copying the item. Removing or changing is
      // managed above.
      if ($hunkMode === NULL) {
        $hunkMode = $diff[$i][1];
      }
      elseif ($hunkMode !== $diff[$i][1]) {
        $ops[] = $this->hunkOp($hunkMode, $hunkSource, $hunkTarget);
        $hunkMode = $diff[$i][1];
        $hunkSource = [];
        $hunkTarget = [];
      }

      $hunkSource[] = $diff[$i][0];
    }

    if ($hunkMode !== NULL) {
      $ops[] = $this->hunkOp($hunkMode, $hunkSource, $hunkTarget);
    }

    return $ops;
  }

  /**
   * Returns the proper DiffOp object based on the hunk mode.
   *
   * @param int $mode
   *   A Differ constant or self::CHANGED.
   * @param string[] $source
   *   An array of strings to be changed/added/removed/copied.
   * @param string[] $source
   *   The array of strings to be changed to when self::CHANGED is specified.
   *
   * @return \Drupal\Component\Diff\Engine\DiffOp
   *   A DiffOp* value object.
   *
   * @throw \InvalidArgumentException
   *   When $mode is not valid.
   */
  private function hunkOp(int $mode, array $source, array $target): DiffOp {
    switch ($mode) {
      case Differ::OLD:
        return new DiffOpCopy($source);

      case self::CHANGED:
        return new DiffOpChange($source, $target);

      case Differ::ADDED:
        return new DiffOpAdd($source);

      case Differ::REMOVED:
        return new DiffOpDelete($source);

    }
    throw new \InvalidArgumentException("Invalid \$mode {$mode} specified");
  }

}