lookout 2.0.1

data/Rakefile

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'lookout/rake/tasks'
+
+Lookout::Rake::Tasks::Test.new do |t|
+  ENV['LOOKOUT_DO_NOT_FILTER_BACKTRACE'] = ''
+end
+Lookout::Rake::Tasks::Gem.new

data/lib/lookout.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+module Lookout
+  autoload :Aphonic, 'lookout/aphonic'
+  autoload :Benchmark, 'lookout/benchmark'
+  autoload :Diff, 'lookout/diff'
+  autoload :Equality, 'lookout/equality'
+  autoload :Expectation, 'lookout/expectation'
+  autoload :Expectations, 'lookout/expectations'
+  autoload :Output, 'lookout/output'
+  autoload :Mock, 'lookout/mock'
+  autoload :Recorder, 'lookout/recorder'
+  autoload :Recorders, 'lookout/recorders'
+  autoload :Result, 'lookout/result'
+  autoload :Results, 'lookout/results'
+  autoload :Runners, 'lookout/runners'
+  autoload :Stub, 'lookout/stub'
+  autoload :UI, 'lookout/ui'
+  autoload :Version, 'lookout/version'
+  autoload :XML, 'lookout/xml'
+  
+  class << self
+    def runner(runner = nil)
+      return @runner = runner if runner
+      @runner ||= Lookout::Runners::Console.new.install
+    end
+  end
+end
+
+require 'lookout/object'
+
+def Expectations(&block)
+  Lookout.runner.expectations_eval(&block)
+end

data/lib/lookout/aphonic.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Aphonic
+  Methods = [
+    :__id__, :__send__, :object_id, # Methods that must be defined
+    :extend, :is_a? # Methods that we need
+  ]
+
+  def self.silence(name)
+    undef_method name if
+      instance_methods.include?(RUBY_VERSION < '1.9' ? name.to_s : name.to_sym) and
+      not Methods.include? name.to_sym
+  end
+
+  instance_methods.each do |name|
+    silence name
+  end
+end
+
+[Kernel, Object].each do |object|
+  object.instance_eval{ class << self; self; end }.instance_eval do
+    method_added = method(:method_added)
+    define_method :method_added do |name|
+      result = method_added.call(name)
+      Lookout::Aphonic.silence name if self == object
+      result
+    end
+  end
+end
+
+class Module
+  append_features = instance_method(:append_features)
+  define_method :append_features do |mod|
+    result = append_features.bind(self).call(mod)
+    instance_methods.each do |name|
+      Lookout::Aphonic.silence name
+    end if mod == Object
+    result
+  end
+end

data/lib/lookout/benchmark.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Benchmark
+  class << self
+    def time
+      start = Time.now.to_f
+      yield
+      Time.now.to_f - start
+    end
+  end
+end

data/lib/lookout/diff.rb

@@ -0,0 +1,10 @@
+module Lookout::Diff
+  autoload :Algorithms, 'lookout/diff/algorithms'
+  autoload :Formats, 'lookout/diff/formats'
+  autoload :Group, 'lookout/diff/group'
+  autoload :Groups, 'lookout/diff/groups'
+  autoload :Match, 'lookout/diff/match'
+  autoload :Operation, 'lookout/diff/operation'
+  autoload :Operations, 'lookout/diff/operations'
+  autoload :Range, 'lookout/diff/range'
+end

data/lib/lookout/diff/algorithms.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Diff::Algorithms
+  autoload :Difflib, 'lookout/diff/algorithms/difflib'
+end

data/lib/lookout/diff/algorithms/difflib.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Algorithms::Difflib
+  autoload :Position, 'lookout/diff/algorithms/difflib/position'
+
+  include Enumerable
+
+  def initialize(from, to, &is_junk)
+    @from, @to, @is_junk = from, to, is_junk
+  end
+
+  def each
+    current = Lookout::Diff::Match.new(Lookout::Diff::Range.new(@from, 0...0),
+                                       Lookout::Diff::Range.new(@to, 0...0))
+    stack = [Position.origin(@from, @to, &@is_junk)]
+    until stack.empty?
+      case item = stack.pop
+      when Position
+        match = item.match
+        next if match.empty?
+        stack.push item.begin_after(match) if item.ends_after? match
+        stack.push match
+        stack.push item.end_before(match) if item.begins_before? match
+      when Lookout::Diff::Match
+        if current.touches? item
+          current += item
+        else
+          yield current unless current.empty?
+          current = item
+        end
+      end
+    end
+    yield current unless current.empty?
+    yield Lookout::Diff::Match.new(current.from.at(@from.size...@from.size),
+                                   current.to.at(@to.size...@to.size))
+    self
+  end
+end

data/lib/lookout/diff/algorithms/difflib/position.rb

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Algorithms::Difflib::Position
+  autoload :To, 'lookout/diff/algorithms/difflib/position/to'
+
+  class << self
+    def origin(from, to)
+      to = To.new(to)
+      new(Lookout::Diff::Range.new(from),
+          to,
+          block_given? ?
+            to.indexes.reduce({}){ |j, (k, v)| j[k] = yield(k); j } :
+            {})
+    end
+  end
+
+  def initialize(from, to, junk)
+    @from, @to, @junk = from, to, junk
+  end
+
+  def match
+    match = leftmost_longest
+    junk.empty? ? match : expand(expand(match, false), true)
+  end
+
+  def begins_before?(match)
+    from.begins_before? match.from and to.begins_before? match.to
+  end
+
+  def ends_after?(match)
+    from.ends_after? match.from and to.ends_after? match.to
+  end
+
+  def begin_after(match)
+    self.class.new(from.begin_after(match.from), to.begin_after(match.to), junk)
+  end
+
+  def end_before(match)
+    self.class.new(from.end_before(match.from), to.end_before(match.to), junk)
+  end
+
+  def ==(other)
+    from == other.from and to == other.to and junk == other.junk
+  end
+
+  def inspect
+    '#<%s %p,%p>' % [self.class, from, to]
+  end
+
+protected
+
+  attr_reader :from, :to, :junk
+
+private
+
+  def leftmost_longest
+    match = Lookout::Diff::Match.new(@from.at(0...0), @to.at(0...0))
+    sizes = Hash.new(0)
+    @from.each_with_index do |item, from|
+      _sizes = Hash.new(0)
+      @to.each_index(item) do |to|
+        size = _sizes[to] = sizes[to - 1] + 1
+        match = Lookout::Diff::Match.
+          new(@from.at(from - size + 1..from),
+              @to.at(to - size + 1..to)) if size > match.size
+      end unless junk[item]
+      sizes = _sizes
+    end
+    match
+  end
+
+  def expand(match, junking)
+    from_begin, to_begin = match.from.begin, match.to.begin
+    while from_begin > @from.begin and to_begin > @to.begin and
+          junk[@to[to_begin - 1]] ^ !junking and
+          @from[from_begin - 1] == @to[to_begin - 1]
+      from_begin -= 1
+      to_begin -= 1
+    end
+
+    from_end, to_end = match.from.end, match.to.end
+    while from_end + 1 <= @from.end and to_end + 1 <= @to.end and
+          junk[@to[to_end + 1]] ^ !junking and
+          @from[from_end + 1] == @to[to_end + 1]
+      from_end += 1
+      to_end += 1
+    end
+
+    Lookout::Diff::Match.new(from.at(from_begin..from_end),
+                             to.at(to_begin..to_end))
+  end
+end

data/lib/lookout/diff/algorithms/difflib/position/to.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Algorithms::Difflib::Position::To <
+      Lookout::Diff::Range
+  def initialize(items, range = 0...items.size, indexes = nil)
+    super items, range
+    @indexes = indexes
+  end
+
+  def each_index(item)
+    indexes[item].each do |index|
+      next if index < range.begin
+      break if index > range.end
+      yield index
+    end
+  end
+
+  def indexes
+    return @indexes if @indexes
+    @indexes = Hash.new{ |h, k| h[k] = [] }
+    each = items.is_a?(String) ?
+        (' '[0].is_a?(Integer) ? :each_byte : :each_char) :
+        :each
+    i = 0
+    items.send(each) do |item|
+      @indexes[item] << i
+      i += 1
+    end
+    @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
+end

data/lib/lookout/diff/formats.rb

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Diff::Formats
+  autoload :Hash, 'lookout/diff/formats/hash'
+  autoload :Inline, 'lookout/diff/formats/inline'
+  autoload :Unified, 'lookout/diff/formats/unified'
+end

data/lib/lookout/diff/formats/hash.rb

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Formats::Hash
+  include Enumerable
+
+  def initialize(operations)
+    @operations = operations
+  end
+
+  def each
+    @operations.each do |op|
+      operation = Operation.new(op)
+      yield operation.to_s unless operation.empty?
+    end
+  end
+
+private
+
+  class Operation
+    def initialize(operation)
+      @lines = operation.apply(self)
+    end
+
+    def empty?
+      @lines.nil?
+    end
+
+    def delete(operation)
+      mark('-', operation.from)
+    end
+
+    def equal(operation)
+    end
+
+    def insert(operation)
+      mark('+', operation.to)
+    end
+
+    def replace(operation)
+      delete(operation) + insert(operation)
+    end
+
+    def to_s
+      @lines.join("\n")
+    end
+
+  private
+
+    def mark(mark, range)
+      range.map{ |item| '%s%s' % [mark, item] }
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Formats::Inline
+  def initialize(operations)
+    @to_s = ToS.new(operations).to_s
+  end
+
+  def to_s
+    @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.from.to_items
+    end
+
+    def equal(operation)
+      operation.from.to_items
+    end
+
+    def insert(operation)
+      '{+%s+}' % operation.to.to_items
+    end
+
+    def replace(operation)
+      delete(operation) + insert(operation)
+    end
+
+    def to_s
+      @to_s
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Diff::Formats::Unified
+  include Enumerable
+
+  def initialize(groups)
+    @groups = groups
+  end
+
+  def each
+    @groups.each do |group|
+      next if group.parity?
+      yield Group.new(group).to_s
+    end
+    self
+  end
+
+private
+
+  class Group
+    def initialize(group)
+      @group = group
+    end
+
+    def delete(operation)
+      mark('-', operation.from)
+    end
+
+    def equal(operation)
+      mark(' ', operation.from)
+    end
+
+    def insert(operation)
+      mark('+', operation.to)
+    end
+
+    def replace(operation)
+      delete(operation).concat(insert(operation))
+    end
+
+    def to_s
+      lines = ['@@ -%d,%d +%d,%d @@' %
+               [@group.from.begin + 1, @group.from.size,
+                @group.to.begin + 1, @group.to.size]]
+      @group.each do |operation|
+        lines.concat operation.apply(self)
+      end
+      lines.join("\n")
+    end
+
+  private
+
+    def mark(mark, range)
+      range.map{ |item| '%s%s' % [mark, item] }
+    end
+  end
+end