lookout 2.3.0 → 3.0.0

data/lib/lookout.rb

@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Lookout
-  autoload :Aphonic, 'lookout/aphonic'
-  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 :Warning, 'lookout/warning'
-  autoload :XML, 'lookout/xml'
-  
-  class << self
-    def location(location)
-      return nil, nil unless match = /\A(.*):(\d+)(?::in .*)?\z/.match(location)
-      [match[1], match[2].to_i]
-    end
-  end
-end
-
-require 'lookout/object'

data/lib/lookout/aphonic.rb

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

@@ -1,10 +0,0 @@
-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/difflib.rb

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

@@ -1,92 +0,0 @@
-# -*- 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, _)| 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/formats.rb

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

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

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

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

data/lib/lookout/diff/group.rb

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

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