lookout 2.3.0 → 3.0.0

data/lib/lookout/diff/match.rb

@@ -1,36 +0,0 @@
-# -*- 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

@@ -1,33 +0,0 @@
-# -*- 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

@@ -1,36 +0,0 @@
-# -*- 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

@@ -1,9 +0,0 @@
-# -*- 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

@@ -1,27 +0,0 @@
-# -*- 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

@@ -1,9 +0,0 @@
-# -*- 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

@@ -1,9 +0,0 @@
-# -*- 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

@@ -1,91 +0,0 @@
-# -*- 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/equalities.rb

@@ -1,13 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Lookout::Equalities
-  require 'lookout/equalities/object'
-  require 'lookout/equalities/array'
-  require 'lookout/equalities/boolean'
-  require 'lookout/equalities/hash'
-  require 'lookout/equalities/include'
-  require 'lookout/equalities/output'
-  require 'lookout/equalities/standarderror'
-  require 'lookout/equalities/string'
-  require 'lookout/equalities/warning'
-end

data/lib/lookout/equalities/array.rb

@@ -1,22 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Equalities::Array < Lookout::Equalities::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

data/lib/lookout/equalities/boolean.rb

@@ -1,9 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Equalities::Boolean < Lookout::Equalities::Object
-  Lookout::Equality.register self, TrueClass, FalseClass
-
-  def equal?(expected, actual)
-    expected == !!actual
-  end
-end

data/lib/lookout/equalities/hash.rb

@@ -1,25 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Equalities::Hash < Lookout::Equalities::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
-

data/lib/lookout/equalities/include.rb

@@ -1,9 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Equalities::Includes < Lookout::Equalities::Object
-  Lookout::Equality.register self, Module, Range, Regexp
-
-  def equal?(expected, actual)
-    expected === actual or expected == actual
-  end
-end

data/lib/lookout/equalities/object.rb

@@ -1,24 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Equalities::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

data/lib/lookout/equalities/output.rb

@@ -1,19 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Equalities::Output < Lookout::Equalities::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

data/lib/lookout/equalities/standarderror.rb

@@ -1,32 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Equalities::StandardError < Lookout::Equalities::Object
-  Lookout::Equality.register self, ::StandardError
-
-  def equal?(expected, actual)
-    expected.equal?(actual) or
-      ((actual.respond_to? :message rescue false) and
-       ((regexp(expected) and regexp(expected) === 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) ?
-      '%p≠#<%s: %p>' % [actual, expected.class, regexp(expected)] :
-      super
-  end
-
-  def regexp(expected)
-    return expected.message if Regexp === expected.message
-    return Regexp.new(expected.message) if expected.message =~ /\A\(\?-[mix]+:.*\)\z/
-    nil
-  end
-end

data/lib/lookout/equalities/string.rb

@@ -1,19 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Equalities::String < Lookout::Equalities::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