lookout 2.3.0 → 3.0.0

data/lib/{lookout/diff/algorithms/difflib/position/to.rb → lookout-3.0/diff/algorithms/difflib/position/new.rb}

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::Diff::Algorithms::Difflib::Position::To <
-      Lookout::Diff::Range
+class Lookout::Diff::Algorithms::Difflib::Position::New <
+      Lookout::Diff::Slice
   def initialize(items, range = 0...items.size, indexes = nil)
     super items, range
     @indexes = indexes
@@ -29,19 +29,10 @@ class Lookout::Diff::Algorithms::Difflib::Position::To <
     @indexes
   end
 
-  def begin_after(other)
-    self.class.new(items, other.range.end + 1..range.end, indexes)
-  end
-
-  def end_before(other)
-    self.class.new(items, range.begin...other.range.begin, indexes)
-  end
-
-  def at(range)
-    Lookout::Diff::Range.new(items, range)
-  end
-
-  def ==(other)
-    super and indexes == other.indexes
-  end
+  def begin_after(other) self.class.new(items, other.end + 1..self.end, indexes) end
+  def end_before(other) self.class.new(items, self.begin...other.begin, indexes) end
+  def at(range) Lookout::Diff::Slice.new(items, range) end
+  def ==(other) super and indexes == other.indexes end
+  alias eql? ==
+  def hash; @hash ||= super ^ indexes.hash end
 end

data/lib/lookout-3.0/diff/formats.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+# Namespace for “diff” output formats.
+module Lookout::Diff::Formats
+end

data/lib/lookout-3.0/diff/formats/inline.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+# Formats {Operation}s inline in a String.  Additions are shown as `{+…+}` and
+# deletions as `[-…-]`.  Replacements are shown as a deletion followed by an
+# insertion.
+#
+# This format is used by {Difference::String} for single-line Strings.
+#
+# This format is inspired by the plain word “diff” format used by
+# [Git](http://git-scm.com/).  That format was surely inspired by something
+# before it, but it’s where I first saw it, so that’s what I’m referencing.
+class Lookout::Diff::Formats::Inline
+  # Formats OPERATIONS as they would be applied inline on a String.
+  # @param [Operations] operations
+  Value(:operations)
+  include Enumerable
+
+  # @overload
+  #   Enumerates the formatted operations.
+  #
+  #   @yieldparam [String] string
+  # @overload
+  #   @return [Enumerator<String>] An Enumerator over the formatted operations
+  def each
+    return enum_for(__method__) unless block_given?
+    yield to_s
+    self
+  end
+
+  # @return The concatenation of the formatted operations
+  def to_s; @to_s ||= ToS.new(operations).to_s end
+
+  private
+
+  class ToS
+    def initialize(operations) @to_s = operations.map{ |o| o.apply(self) }.join('').freeze end
+    def delete(operation) '[-%s-]' % operation.old.to_items end
+    def copy(operation) operation.old.to_items end
+    def insert(operation) '{+%s+}' % operation.new.to_items end
+    def replace(operation) delete(operation) + insert(operation) end
+    def to_s; @to_s end
+  end
+end

data/lib/lookout-3.0/diff/formats/set.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+
+# Formats {Operation}s on an undordered set.  Added subsequences are shown
+# having each element prefixed by “+” and deleted subsequences by “-”.
+# Replaced subsequences are shown as a deleted subsequence followed by an added
+# subsequence.
+#
+# This format is used by {Difference::Hash}.
+class Lookout::Diff::Formats::Set
+  # Formats OPERATIONS as they would be applied to an unordered set.
+  # @param [Operations] operations
+  Value(:operations)
+  include Enumerable
+
+  # @overload
+  #   Enumerates the formatted operations.
+  #
+  #   @yieldparam [String] string
+  # @overload
+  #   @return [Enumerator<String>] Enumerator over the formatted operations
+  def each
+    return enum_for(__method__) unless block_given?
+    operations.each do |op|
+      operation = ToS.new(op)
+      yield operation.to_s unless operation.empty?
+    end
+    self
+  end
+
+  # @return The concatenation of the formatted operations
+  def to_s; to_a.join("\n") end
+
+  private
+
+  class ToS
+    def initialize(operation) @lines = operation.apply(self) end
+    def empty?; @lines.nil? end
+    def delete(operation) mark('-', operation.old) end
+    def copy(operation) end
+    def insert(operation) mark('+', operation.new) end
+    def replace(operation) delete(operation) + insert(operation) end
+    def to_s; @lines.join("\n") end
+
+    private
+
+    def mark(mark, slice) slice.map{ |item| [mark, item].join('') } end
+  end
+end

data/lib/lookout-3.0/diff/formats/unified.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+
+# Formats {Group}s in unified format.  This format shows {Groups} of related
+# operations, providing a script of changes to be made that is both human and
+# computer readable.  For more information, see
+# {http://en.wikipedia.org/wiki/Diff#Unified_format}.
+#
+# This format is used by {Difference::String} for multi-line Strings.
+class Lookout::Diff::Formats::Unified
+  # Formats GROUPS in unified format.
+  # @param [Groups] groups
+  Value(:groups)
+  include Enumerable
+
+  # @overload
+  #   Enumerates the formatted groups.
+  #
+  #   @yieldparam [String] string
+  # @overload
+  #   @return [Enumerator<String>] An Enumerator over the formatted groups
+  def each
+    return enum_for(__method__) unless block_given?
+    groups.each do |group|
+      next if group.parity?
+      yield ToS.new(group).to_s
+    end
+    self
+  end
+
+  # @return The concatenation of the formatted groups
+  def to_s; to_a.join("\n") end
+
+  private
+
+  class ToS
+    def initialize(group) @group = group end
+    def delete(operation) mark('-', operation.old) end
+    def copy(operation) mark(' ', operation.old) end
+    def insert(operation) mark('+', operation.new) end
+    def replace(operation) delete(operation).concat(insert(operation)) end
+
+    def to_s
+      lines = ['@@ -%d,%d +%d,%d @@' %
+               [@group.old.begin + 1, @group.old.size,
+                @group.new.begin + 1, @group.new.size]]
+      @group.each do |operation|
+        lines.concat operation.apply(self)
+      end
+      lines.join("\n")
+    end
+
+    private
+
+    def mark(mark, slice) slice.map{ |item| [mark, item].join('') } end
+  end
+end

data/lib/lookout-3.0/diff/group.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+
+# Ordered sequence of related {Operation}s; type enumerated by {Groups}.
+class Lookout::Diff::Group
+  # Initializes the group with an initial sequence of OPERATIONS.
+  # @param [Operation, …] operations
+  Value(:'*operations')
+  include Enumerable
+
+  # @return True if the receiver doesn’t contain any operations
+  def empty?; operations.empty? end
+
+  # Adds OPERATION to the receiver.
+  #
+  # @param [Operation] operation
+  def <<(operation) operations << operation; self end
+
+  # {Operation#<< Folds} the last operation, leaving CONTEXT elements of
+  # context.
+  #
+  # @param [Integer] context
+  # @return [self]
+  def fold(context) operations[-1] = operations[-1] << context; self end
+
+  # @return True if the receiver contains one operation and that operation
+  #   represents {Operation#parity? parity}
+  def parity?
+    operations.size == 1 and operations.first.parity?
+  end
+
+  # @overload
+  #   Enumerates the operations.
+  #
+  #   @yieldparam [Operation] operation
+  # @overload
+  #   @return [Enumerator<Operation>] An Enumerator over the operations
+  def each
+    return enum_for(__method__) unless block_given?
+    operations.each do |operation| yield operation end
+    self
+  end
+
+  # @return [Slice] The slice of the old sequence between the first operation’s
+  #   beginning and the last operation’s end
+  def old; slice(:old) end
+
+  # @return [Slice] The slice of the new sequence between the first operation’s
+  #   beginning and the last operation’s end
+  def new; slice(:new) end
+
+  private
+
+  def slice(target)
+    # TODO: Should be #end_after(operations.last.send(target))
+    operations.first.send(target).end_at(operations.last.send(target).end)
+  end
+end

data/lib/lookout-3.0/diff/groups.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+# Sequence of {Operations} bundled together into {Group}s that can then be used
+# to show the subsequences that differ, folding away the subsequences that are
+# the same, only keeping some context around the folding points.
+class Lookout::Diff::Groups
+  # Initializes the sequence with the OPERATIONS to group and the number of
+  # elements to leave as CONTEXT.
+  #
+  # @param [Operations] operations
+  # @param [Integer] context
+  Value(:operations, [:context, 3])
+  include Enumerable
+
+  # @overload
+  #   Enumerates the groups of operations.
+  #
+  #   @yieldparam [Group] group
+  # @overload
+  #   @return [Enumerator<Group>] An Enumerator over the groups of operations
+  def each
+    return enum_for(__method__) unless block_given?
+    saved = nil
+    group = Lookout::Diff::Group.new
+    operations.each do |operation|
+      if saved
+        yield saved
+        saved = nil
+      end
+      if group.empty?
+        operation = operation >> context
+        group << operation
+      elsif operation.foldable? context
+        saved = group << (operation << context)
+        group = Lookout::Diff::Group.new(operation >> context)
+      else
+        group << operation
+      end
+    end
+    if saved
+      yield saved
+    elsif not group.empty?
+      yield group.fold(context)
+    end
+    self
+  end
+end

data/lib/lookout-3.0/diff/match.rb

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+
+# Matching pair of {Slice}s of the sequences being “diffed”.
+class Lookout::Diff::Match
+  # Initializes a match between OLD and NEW.
+  # @param [Slice] old The slice of the old sequence
+  # @param [Slice] new The slice of the new sequence
+  Value(:old, :new, :comparable => true)
+  public :old, :new
+
+  # @return True if the matching sequences are empty
+  def empty?; old.empty? end
+
+  # @return The number of matching elements
+  def size; old.size end
+
+  # @return A new match {Slice#+ encompassing} the slices of the
+  #   receiver and OTHER
+  # @note Logically, the receiver should {#touch?} OTHER, but this isn’t
+  #   enforced.
+  def +(other) self.class.new(old + other.old, new + other.new) end
+
+  # @return True if {#old} and {#new} {Slice#touch? #touch?} those of OTHER
+  def touch?(other) old.touch? other.old and new.touch? other.new end
+
+  # @param [Range] old
+  # @param [Range] new
+  # @return [Match] A new match with {#old} and {#new} {Slice#at #at} OLD
+  #   and NEW
+  def at(old, new) self.class.new(self.old.at(old), self.new.at(new)) end
+end

data/lib/lookout-3.0/diff/operation.rb

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+# Base class for operations describing the changes to perform to get from the
+# old version of a sequence to the new in a “diff”.
+class Lookout::Diff::Operation
+  # Initializes the operation with the slices of the OLD and NEW sequences.
+  # @param [Slice] old The slice of the old sequence
+  # @param [Slice] new The slice of the new sequence
+  Value(:old, :new)
+  public :old, :new
+
+  # @param [Integer] context
+  # @return True if the operation is uninteresting to the actual “diff” and can
+  #   be meaningfully folded, leaving CONTEXT elements
+  # @see Operations::Copy#foldable?
+  def foldable?(context) false end
+
+  # Folds from the beginning of the receiver, leaving CONTEXT elements.
+  # @param [Integer] context
+  # @note Logically, the receiver should be {#foldable?} inside CONTEXT, but
+  #   this isn’t enforced.
+  def >>(context) self end
+
+  # Folds from the end of the receiver, leaving CONTEXT elements.
+  # @param [Integer] context
+  # @note Logically, the receiver should be {#foldable?} inside CONTEXT, but
+  #   this isn’t enforced.
+  def <<(context) self end
+
+  # @return True if the receiver represents parity
+  # @see Operations::Copy#parity?
+  def parity?; false end
+
+  # Implements a double dispatch for enumerating operations, where OBJECT is
+  # sent the last part of the receiver’s class’ name with the receiver as the
+  # lone argument.
+  # @return The result of OBJECT#name(self)
+  def apply(object)
+    object.send(@apply ||= self.class.name.split('::').last.downcase.to_sym, self)
+  end
+end

data/lib/lookout-3.0/diff/operations.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+# Sequence of {Operation}s based on a sequence of {Match}es.  Each match is
+# turned into a {Copy}, {Delete}, {Insert}, or {Replace} operation based on its
+# relation to other matches in the sequence of matches.  Empty copy operations
+# will never be a part of this sequence.
+class Lookout::Diff::Operations
+  # Initializes a sequence of operations based on MATCHES.
+  # @param [Enumerable<Match>] matches
+  Value(:matches)
+  include Enumerable
+
+  # @overload
+  #   Enumerates the operations.
+  #
+  #   @yieldparam [Operation] operation
+  # @overload
+  #   @return [Enumerator<Operation>] An Enumerator over the operations
+  def each
+    return enum_for(__method__) unless block_given?
+    old = new = 0
+    matches.each do |match|
+      type = if    old < match.old.begin and new < match.new.begin then Replace
+             elsif old < match.old.begin                           then Delete
+             elsif new < match.new.begin                           then Insert
+             else                                                       Copy
+             end
+      yield type.new(match.old.at(old...match.old.begin),
+                     match.new.at(new...match.new.begin)) unless type == Copy
+      yield Copy.new(match.old, match.new) unless match.empty?
+      old, new = match.old.end + 1, match.new.end + 1
+    end
+    self
+  end
+end

data/lib/lookout-3.0/diff/operations/copy.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+# Slice that should be copied from the old sequence.
+class Lookout::Diff::Operations::Copy < Lookout::Diff::Operation
+  # @param [Integer] context
+  # @return True if the slice of the old sequence is larger than CONTEXT * 2
+  #   ({#old}{Slice#size #size} > CONTEXT * 2) so that it may be folded to
+  #   CONTEXT at both ends ({#>>}, {#<<})
+  def foldable?(context) old.size > context * 2 end
+
+  # (see Operation#>>)
+  def >>(context)
+    self.class.new(old.begin_at([old.begin, old.end - context + 1].max),
+                   new.begin_at([new.begin, new.end - context + 1].max))
+  end
+
+  # (see Operation#<<)
+  def <<(context)
+    self.class.new(old.end_at([old.end, old.begin + context - 1].min),
+                   new.end_at([new.end, new.begin + context - 1].min))
+  end
+
+  # @return True if {#old} `#==` {#new}
+  def parity?; old == new end
+end

data/lib/lookout-3.0/diff/operations/delete.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+# Slice that should be deleted from the old sequence.
+class Lookout::Diff::Operations::Delete < Lookout::Diff::Operation
+end

data/lib/lookout-3.0/diff/operations/insert.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+# Slice that should be inserted from the new sequence.
+class Lookout::Diff::Operations::Insert < Lookout::Diff::Operation
+end