lookout 2.0.1

data/lib/lookout/diff/group.rb

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Group
+  include Enumerable
+
+  def initialize(*operations)
+    @operations = operations
+  end
+
+  def empty?
+    operations.empty?
+  end
+
+  def <<(operation)
+    operations << operation
+    self
+  end
+
+  def fold(context)
+    operations[-1] = operations[-1] << context
+    self
+  end
+
+  def parity?
+    operations.size == 1 and operations.first.parity?
+  end
+
+  def each
+    operations.each do |operation|
+      yield operation
+    end
+    self
+  end
+
+  def from
+    range(:from)
+  end
+
+  def to
+    range(:to)
+  end
+
+  def ==(other)
+    operations == other.operations
+  end
+
+  def inspect
+    '<#%s %p>' % [self.class, operations]
+  end
+
+protected
+
+  attr_reader :operations
+
+private
+
+  def range(target)
+    operations.first.send(target).
+      at(operations.first.send(target).begin..operations.last.send(target).end)
+  end
+end

data/lib/lookout/diff/groups.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Groups
+  include Enumerable
+
+  def initialize(operations, context = 3)
+    @operations, @context = operations, context
+  end
+
+  def each
+    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 * 2
+        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
+  end
+end

data/lib/lookout/diff/match.rb

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Match
+  include Comparable
+
+  def initialize(from, to)
+    @from, @to = from, to
+  end
+
+  def empty?
+    from.empty?
+  end
+
+  def size
+    from.size
+  end
+
+  def +(other)
+    self.class.new(from + other.from, to + other.to)
+  end
+
+  def touches?(other)
+    from.end + 1 == other.from.begin and to.end + 1 == other.to.begin
+  end
+
+  def <=>(other)
+    [from.begin, from.end, to.begin, to.end] <=>
+      [other.from.begin, other.from.end, other.to.begin, other.to.end]
+  end
+
+  def inspect
+    '#<%s %p==%p>' % [self.class, from, to]
+  end
+
+  attr_reader :from, :to
+end

data/lib/lookout/diff/operation.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Diff::Operation
+  def initialize(from, to)
+    @from, @to = from, to
+  end
+
+  def foldable?(window)
+    false
+  end
+
+  def >>(size)
+    self
+  end
+
+  def <<(size)
+    self
+  end
+
+  def parity?
+    false
+  end
+
+  def ==(other)
+    from == other.from and to == other.to
+  end
+
+  def inspect
+    '#<%s %p,%p>' % [self.class, from, to]
+  end
+
+  attr_reader :from, :to
+end

data/lib/lookout/diff/operations.rb

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Operations
+  autoload :Delete, 'lookout/diff/operations/delete'
+  autoload :Equal, 'lookout/diff/operations/equal'
+  autoload :Insert, 'lookout/diff/operations/insert'
+  autoload :Replace, 'lookout/diff/operations/replace'
+
+  include Enumerable
+
+  def initialize(matches)
+    @matches = matches
+  end
+
+  def each
+    from = to = 0
+    @matches.each do |match|
+      type = typeify(from, to, match)
+      yield type.new(match.from.at(from...match.from.begin),
+                     match.to.at(to...match.to.begin)) unless type == Equal
+      yield Equal.new(match.from, match.to) unless match.empty?
+      from, to = match.from.end + 1, match.to.end + 1
+    end
+    self
+  end
+
+private
+
+  def typeify(from, to, match)
+    if    from < match.from.begin and to < match.to.begin then Replace
+    elsif from < match.from.begin                         then Delete
+    elsif to < match.to.begin                             then Insert
+    else                                                       Equal
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Operations::Delete
+  include Lookout::Diff::Operation
+
+  def apply(object)
+    object.delete(self)
+  end
+end

data/lib/lookout/diff/operations/equal.rb

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Operations::Equal
+  include Lookout::Diff::Operation
+
+  def foldable?(window)
+    from.size > window
+  end
+
+  def >>(size)
+    self.class.new(from.begin_at([from.begin, from.end - size + 1].max),
+                   to.begin_at([to.begin, to.end - size + 1].max))
+  end
+
+  def <<(size)
+    self.class.new(from.end_at([from.end, from.begin + size - 1].min),
+                   to.end_at([to.end, to.begin + size - 1].min))
+  end
+
+  def parity?
+    from == to
+  end
+
+  def apply(object)
+    object.equal(self)
+  end
+end

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

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Operations::Insert
+  include Lookout::Diff::Operation
+
+  def apply(object)
+    object.insert(self)
+  end
+end

data/lib/lookout/diff/operations/replace.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Operations::Replace
+  include Lookout::Diff::Operation
+
+  def apply(object)
+    object.replace(self)
+  end
+end

data/lib/lookout/diff/range.rb

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Range
+  include Enumerable
+
+  def initialize(items, range = 0...items.size)
+    @items, @range = items, range.exclude_end? ? range.begin..range.end - 1 : range
+  end
+
+  def empty?
+    size < 1
+  end
+
+  def size
+    range.end - range.begin + 1
+  end
+
+  def begins_before?(other)
+    range.begin < other.range.begin
+  end
+
+  def ends_after?(other)
+    range.end > other.range.end
+  end
+
+  def begin_after(other)
+    self.class.new(items, other.range.end + 1..range.end)
+  end
+
+  def end_before(other)
+    self.class.new(items, range.begin...other.range.begin)
+  end
+
+  def at(range)
+    self.class.new(items, range)
+  end
+
+  def +(other)
+    self.class.new(items, range.begin..other.range.end)
+  end
+
+  def begin_at(index)
+    self.class.new(items, index..range.end)
+  end
+
+  def end_at(index)
+    self.class.new(items, range.begin..index)
+  end
+
+  def each
+    range.each do |index|
+      yield items[index]
+    end
+    self
+  end
+
+  def each_with_index
+    range.each do |index|
+      yield items[index], index
+    end
+    self
+  end
+
+  def to_items
+    items[range]
+  end
+
+  def [](index)
+    items[index]
+  end
+
+  def begin
+    range.begin
+  end
+
+  def end
+    range.end
+  end
+
+  def ==(other)
+    range == other.range and items == other.items
+  end
+
+  def inspect
+    '%p[%p]' % [items, range]
+  end
+
+protected
+
+  attr_reader :items, :range
+end

data/lib/lookout/equality.rb

@@ -0,0 +1,178 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Equality
+  class << self
+    def register(equality, *types)
+      eq = equality.new
+      types.each do |type|
+        equalities[type] = eq
+      end
+    end
+
+    def equal?(expected, actual)
+      self[expected].equal? expected, actual
+    end
+
+    def message(expected, actual)
+      self[expected].message expected, actual
+    end
+
+    def diff(expected, actual)
+      self[expected].diff expected, actual
+    end
+
+  private
+
+    def [](expected)
+      equalities[expected.class.ancestors.find{ |type| equalities[type] }]
+    end
+
+    def equalities
+      @equalities ||= {}
+    end
+  end
+end
+
+class Lookout::Equality::Object
+  Lookout::Equality.register self, Object
+
+  def equal?(expected, actual)
+    expected == actual
+  end
+
+  def message(expected, actual)
+    format = format(expected, actual)
+    return format unless diff = diff(expected, actual)
+    (diff.include?("\n") ? "%s\n%s" : '%s: %s') % [format, diff]
+  end
+
+  def diff(expected, actual)
+  end
+
+private
+
+  def format(expected, actual)
+    '%p≠%p' % [actual, expected]
+  end
+end
+
+class Lookout::Equality::Includes < Lookout::Equality::Object
+  Lookout::Equality.register self, Module, Range, Regexp
+
+  def equal?(expected, actual)
+    expected === actual or expected == actual
+  end
+end
+
+class Lookout::Equality::Boolean < Lookout::Equality::Object
+  Lookout::Equality.register self, TrueClass, FalseClass
+
+  def equal?(expected, actual)
+    expected == !!actual
+  end
+end
+
+class Lookout::Equality::String < Lookout::Equality::Object
+  Lookout::Equality.register self, String
+
+  def diff(expected, actual)
+    return unless String === actual
+    (expected.include? "\n" or actual.include? "\n") ?
+     Lookout::Diff::Formats::Unified.
+       new(Lookout::Diff::Groups.
+             new(Lookout::Diff::Operations.
+                   new(Lookout::Diff::Algorithms::Difflib.
+                         new(actual.split("\n"),
+                             expected.split("\n"))))).to_a.join("\n") :
+     Lookout::Diff::Formats::Inline.
+       new(Lookout::Diff::Operations.
+             new(Lookout::Diff::Algorithms::Difflib.new(actual, expected))).to_s
+  end
+end
+
+class Lookout::Equality::Array < Lookout::Equality::Object
+  Lookout::Equality.register self, Array
+
+  def equal?(expected, actual)
+    return false unless Array === actual and expected.size == actual.size
+    expected.each_with_index do |v, i|
+      return false unless Lookout::Equality.equal? v, actual[i]
+    end
+    true
+  end
+
+  def diff(expected, actual)
+    return if expected.size == 1 or not Array === actual
+    Lookout::Diff::Formats::Unified.
+      new(Lookout::Diff::Groups.
+            new(Lookout::Diff::Operations.
+                  new(Lookout::Diff::Algorithms::Difflib.
+                        new(actual, expected)))).to_a.join("\n")
+  end
+end
+
+class Lookout::Equality::Hash < Lookout::Equality::Object
+  Lookout::Equality.register self, Hash
+
+  def equal?(expected, actual)
+    return false unless Hash === actual and expected.size == actual.size
+    expected.all?{ |k, v| Lookout::Equality.equal? v, actual[k] }
+  end
+
+  def diff(expected, actual)
+    return if expected.size == 1 or not Hash === actual
+    Lookout::Diff::Formats::Hash.
+      new(Lookout::Diff::Operations.
+            new(Lookout::Diff::Algorithms::Difflib.
+                  new(array(actual), array(expected)))).to_a.join("\n")
+  end
+
+private
+
+  def array(hash)
+    hash.to_a.sort_by{ |k, v| k }.map{ |k, v| '%p => %p' % [k, v] }
+  end
+end
+
+class Lookout::Equality::StandardError < Lookout::Equality::Object
+  Lookout::Equality.register self, ::StandardError
+
+  def equal?(expected, actual)
+    expected.equal?(actual) or
+      ((actual.respond_to? :message rescue false) and
+       ((Regexp === expected.message and expected.message === actual.message) or
+        expected.message == actual.message))
+  end
+
+  def diff(expected, actual)
+    return super unless String === expected.message and
+      StandardError === actual and (actual.respond_to? :message rescue false)
+    Lookout::Equality.diff(expected.message, actual.message)
+  end
+
+private
+
+  def format(expected, actual)
+    Regexp === expected.message ?
+      '%p≠#<%s: %p>' % [actual, expected.class, expected.message] :
+      super
+  end
+end
+
+class Lookout::Equality::Output < Lookout::Equality::Object
+  Lookout::Equality.register self, Lookout::Output
+
+  def equal?(expected, _actual)
+    expected.expected == expected.actual
+  end
+
+  def diff(expected, _actual)
+    Lookout::Equality.diff(expected.expected, expected.actual)
+  end
+
+private
+
+  def format(expected, _actual)
+    '%p≠%p' % [Lookout::Output.new(expected.actual), expected]
+  end
+end