lookout 2.3.0 → 3.0.0

data/lib/lookout/stub/method.rb

@@ -1,105 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Stub::Method
-  class Values
-    def initialize(*values)
-      @values = values
-      @offset = -1
-    end
-
-    def next
-      @offset = [@offset + 1, @values.count - 1].min
-      @values[@offset]
-    end
-
-    def call
-      yield(*self.next)
-    end
-  end
-
-  class Each
-    def initialize(*values)
-      @values = values
-    end
-
-    def call
-      @values.each do |value|
-        yield value
-      end
-    end
-  end
-
-  def initialize(object, method, &body)
-    @object, @method, @body = object, method.to_sym, body || Nil
-    @yield = nil
-    @defined = false
-  end
-
-  def yield(*values)
-    @yield = Values.new(*values)
-    self
-  end
-
-  def each(*values)
-    @yield = Each.new(*values)
-    self
-  end
-
-  def define
-    return self if @defined
-    define!
-    @defined = true
-    self
-  end
-
-  def call(*args, &block)
-    @yield.call(&block) if @yield and block
-    @body.call(*args)
-  end
-
-  def undefine
-    return self unless @defined
-    undefine!
-    @defined = false
-    self
-  end
-
-private
-
-  Nil = proc{ Lookout::Stub::Object.new }
-
-  def define!
-    meta.module_exec(@method, visibility, stash, self) do |method, visibility, stash, stub|
-      alias_method stash, method if
-        method_defined? method or private_method_defined? method
-      define_method method do |*args, &block|
-        stub.call(*args, &block)
-      end
-      send visibility, method
-    end
-  end
-
-  def undefine!
-    meta.module_exec(@method, stash) do |method, stash|
-      remove_method method
-      if method_defined? stash or private_method_defined? stash
-        alias_method method, stash
-        remove_method stash
-      end
-    end
-  end
-
-  def visibility
-    meta.private_method_defined?(@method) ? :private :
-      meta.protected_method_defined?(@method) ? :protected :
-        :public
-  end
-
-  def stash
-    :"__stubbed_method_#{@method}"
-  end
-
-  def meta
-    (class << @object; self; end)
-  end
-end

data/lib/lookout/stub/methods.rb

@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Stub::Methods
-  def initialize
-    @methods = []
-  end
-
-  def define(object, method, &body)
-    Lookout::Stub::Method.new(object, method, &body).define.tap{ |m| @methods << m }
-  end
-
-  def undefine
-    @methods.each do |method|
-      method.undefine
-    end
-    self
-  end
-end

data/lib/lookout/stub/object.rb

@@ -1,11 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Stub::Object
-  def inspect
-    'stub'
-  end
-
-  def method_missing(method, *args)
-    self
-  end
-end

data/lib/lookout/ui.rb

@@ -1,7 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Lookout::UI
-  autoload :Console, 'lookout/ui/console'
-  autoload :Formatters, 'lookout/ui/formatters'
-  autoload :Silent, 'lookout/ui/silent'
-end

data/lib/lookout/ui/console.rb

@@ -1,19 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::UI::Console
-  def initialize(results, io = $stderr)
-    @results, @io = results, io
-    results.on_new do |result|
-      @io.puts result unless Lookout::Results::Fulfilled === result
-    end
-  end
-
-  def start
-    self
-  end
-
-  def flush
-    @io.flush
-    self
-  end
-end

data/lib/lookout/ui/silent.rb

@@ -1,9 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::UI::Silent
-  def start
-  end
-
-  def flush
-  end
-end

data/lib/lookout/version.rb

@@ -1,5 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Lookout
-  Version = '2.3.0'
-end

data/lib/lookout/warning.rb

@@ -1,7 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Warning < String
-  def inspect
-    'warning(%s)' % super
-  end
-end

data/lib/lookout/xml.rb

@@ -1,17 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::XML < String
-  def ==(other)
-    not normalize(other).index(normalize).nil?
-  end
-
-  def inspect
-    'xml(%s)' % [normalize]
-  end
-
-private
-
-  def normalize(xml = self)
-    xml.strip.gsub(/>\s*</, '><')
-  end
-end

data/test/unit/lookout/diff/algorithms/difflib.rb

@@ -1,56 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect [Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 0..1),
-                                   Lookout::Diff::Range.new('abcd', 0..1)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 3..4),
-                                   Lookout::Diff::Range.new('abcd', 2..3)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 5...5),
-                                   Lookout::Diff::Range.new('abcd', 4...4))] do
-    Lookout::Diff::Algorithms::Difflib.new('abxcd', 'abcd').to_a
-  end
-
-  expect [Lookout::Diff::Match.new(Lookout::Diff::Range.new('acbxcd', 0..0),
-                                   Lookout::Diff::Range.new('aybcd', 0..0)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('acbxcd', 2..2),
-                                   Lookout::Diff::Range.new('aybcd', 2..2)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('acbxcd', 4..5),
-                                   Lookout::Diff::Range.new('aybcd', 3..4)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('acbxcd', 6...6),
-                                   Lookout::Diff::Range.new('aybcd', 5...5))] do
-    Lookout::Diff::Algorithms::Difflib.new('acbxcd', 'aybcd').to_a
-  end
-
-  expect [Lookout::Diff::Match.new(Lookout::Diff::Range.new('qabxcd', 1..2),
-                                   Lookout::Diff::Range.new('abycdf', 0..1)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('qabxcd', 4..5),
-                                   Lookout::Diff::Range.new('abycdf', 3..4)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('qabxcd', 6...6),
-                                   Lookout::Diff::Range.new('abycdf', 6...6))] do
-    Lookout::Diff::Algorithms::Difflib.new('qabxcd', 'abycdf').to_a
-  end
-
-  expect [Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 0..1),
-                                   Lookout::Diff::Range.new('abcd', 0..1)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 3..4),
-                                   Lookout::Diff::Range.new('abcd', 2..3)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('abxcd', 5...5),
-                                   Lookout::Diff::Range.new('abcd', 4...4)),] do
-    Lookout::Diff::Algorithms::Difflib.new('abxcd', 'abcd').to_a
-  end
-
-  # 0, 0, 8
-  # 8, 17, 21
-  # 29, 38, 0
-  expect [Lookout::Diff::Match.new(Lookout::Diff::Range.new('private Thread currentThread;', 0..7),
-                                   Lookout::Diff::Range.new('private volatile Thread currentThread;', 0..7)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('private Thread currentThread;', 8..28),
-                                   Lookout::Diff::Range.new('private volatile Thread currentThread;', 17..37)),
-          Lookout::Diff::Match.new(Lookout::Diff::Range.new('private Thread currentThread;', 29...29),
-                                   Lookout::Diff::Range.new('private volatile Thread currentThread;', 38...38))] do
-    Lookout::Diff::Algorithms::Difflib.new('private Thread currentThread;',
-                                           'private volatile Thread currentThread;'){ |c|
-      c == ' '[0]
-    }.to_a
-  end
-end

data/test/unit/lookout/diff/algorithms/difflib/position.rb

@@ -1,92 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 0...0),
-                                  Lookout::Diff::Range.new('xyz', 0...0)) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'xyz').match
-  end
-
-  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc'),
-                                  Lookout::Diff::Range.new('abc')) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').match
-  end
-
-  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('Xabc', 1..3),
-                                  Lookout::Diff::Range.new('abc')) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('Xabc', 'abc').match
-  end
-
-  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abcX', 0..2),
-                                  Lookout::Diff::Range.new('abc')) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abcX', 'abc').match
-  end
-
-  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc'),
-                                  Lookout::Diff::Range.new('Xabc', 1..3)) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'Xabc').match
-  end
-
-  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc'),
-                                  Lookout::Diff::Range.new('abcX', 0..2)) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abcX').match
-  end
-
-  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('ab', 0..1),
-                                  Lookout::Diff::Range.new('abXabc', 0..1)) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('ab', 'abXabc').match
-  end
-
-  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc'),
-                                  Lookout::Diff::Range.new('abXabc', 3..5)) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abXabc').match
-  end
-
-  expect Lookout::Diff::Match.new(Lookout::Diff::Range.new(' abc', 1..3),
-                                  Lookout::Diff::Range.new('abc abc', 0..2)) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin(' abc', 'abc abc'){ |c| c == ' '[0] }.match
-  end
-
-  # TODO: Need more tests for is_junk.
-
-  expect false do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
-      begins_before? Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 0..0),
-                                              Lookout::Diff::Range.new('abc', 0..0))
-  end
-
-  expect true do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
-      begins_before? Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 1..1),
-                                              Lookout::Diff::Range.new('abc', 1..1))
-  end
-
-  expect false do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
-      ends_after? Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 3..3),
-                                           Lookout::Diff::Range.new('abc', 3..3))
-  end
-
-  expect true do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('abc', 'abc').
-      ends_after? Lookout::Diff::Match.new(Lookout::Diff::Range.new('abc', 1..1),
-                                           Lookout::Diff::Range.new('abc', 1..1))
-  end
-
-  expect Lookout::Diff::Algorithms::Difflib::Position.
-           new(Lookout::Diff::Range.new('dabcX', 4..4),
-               Lookout::Diff::Algorithms::Difflib::Position::To.new('ddabcY', 5..5),
-               {}) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('dabcX', 'ddabcY').
-      begin_after(Lookout::Diff::Match.new(Lookout::Diff::Range.new('dabcX', 0..3),
-                                           Lookout::Diff::Range.new('ddabcY', 1..4)))
-  end
-
-  expect Lookout::Diff::Algorithms::Difflib::Position.
-           new(Lookout::Diff::Range.new('dabcX', 0...0),
-               Lookout::Diff::Algorithms::Difflib::Position::To.new('ddabcY', 0..0),
-               {}) do
-    Lookout::Diff::Algorithms::Difflib::Position.origin('dabcX', 'ddabcY').
-      end_before(Lookout::Diff::Match.new(Lookout::Diff::Range.new('dabcX', 0..3),
-                                          Lookout::Diff::Range.new('ddabcY', 1..4)))
-  end
-end

data/test/unit/lookout/diff/groups.rb

@@ -1,102 +0,0 @@
-# -*- coding: utf-8 -*-
-
-Expectations do
-  expect [] do
-    Lookout::Diff::Groups.
-      new(Lookout::Diff::Operations.
-            new(Lookout::Diff::Algorithms::Difflib.new('', ''))).to_a
-  end
-
-  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('abc', 0..2),
-                                                                        Lookout::Diff::Range.new('abc', 0..2)))] do
-    Lookout::Diff::Groups.
-      new(Lookout::Diff::Operations.
-            new(Lookout::Diff::Algorithms::Difflib.new('abc', 'abc'))).to_a
-  end
-
-  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('abcdefg', 4..6),
-                                                                        Lookout::Diff::Range.new('abcdefg', 4..6)))] do
-    Lookout::Diff::Groups.
-      new(Lookout::Diff::Operations.
-            new(Lookout::Diff::Algorithms::Difflib.
-                  new('abcdefg',
-                      'abcdefg'))).to_a
-  end
-
-  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('Abcdefg', 0..0),
-                                                                          Lookout::Diff::Range.new('abcdefg', 0..0)),
-                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('Abcdefg', 1..3),
-                                                                        Lookout::Diff::Range.new('abcdefg', 1..3)))] do
-    Lookout::Diff::Groups.
-      new(Lookout::Diff::Operations.
-            new(Lookout::Diff::Algorithms::Difflib.
-                  new('Abcdefg',
-                      'abcdefg'))).to_a
-  end
-
-  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('Abcdefgh', 0..0),
-                                                                          Lookout::Diff::Range.new('abcdefgh', 0..0)),
-                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('Abcdefgh', 1..3),
-                                                                        Lookout::Diff::Range.new('abcdefgh', 1..3)))] do
-    Lookout::Diff::Groups.
-      new(Lookout::Diff::Operations.
-            new(Lookout::Diff::Algorithms::Difflib.
-                  new('Abcdefgh',
-                      'abcdefgh'))).to_a
-  end
-
-  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('abcdefgHijklmno', 4..6),
-                                                                        Lookout::Diff::Range.new('abcdefghijklmno', 4..6)),
-                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('abcdefgHijklmno', 7..7),
-                                                                          Lookout::Diff::Range.new('abcdefghijklmno', 7..7)),
-                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('abcdefgHijklmno', 8..10),
-                                                                        Lookout::Diff::Range.new('abcdefghijklmno', 8..10)))] do
-    Lookout::Diff::Groups.
-      new(Lookout::Diff::Operations.
-            new(Lookout::Diff::Algorithms::Difflib.
-                  new('abcdefgHijklmno',
-                      'abcdefghijklmno'))).to_a
-  end
-
-  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 0..0),
-                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 0..0)),
-                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('123456789abcdefghijk', 1..1),
-                                                                          Lookout::Diff::Range.new('1i3456789abXdhYjk', 1..1)),
-                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 2..4),
-                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 2..4))),
-          Lookout::Diff::Group.new(Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 8..10),
-                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 8..10)),
-                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('123456789abcdefghijk', 11..11),
-                                                                          Lookout::Diff::Range.new('1i3456789abXdhYjk', 11..11)),
-                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 12..12),
-                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 12..12)),
-                                   Lookout::Diff::Operations::Delete.new(Lookout::Diff::Range.new('123456789abcdefghijk', 13..15),
-                                                                         Lookout::Diff::Range.new('1i3456789abXdhYjk', 13...13)),
-                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 16..16),
-                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 13..13)),
-                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new('123456789abcdefghijk', 17..17),
-                                                                          Lookout::Diff::Range.new('1i3456789abXdhYjk', 14..14)),
-                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new('123456789abcdefghijk', 18..19),
-                                                                        Lookout::Diff::Range.new('1i3456789abXdhYjk', 15..16)))] do
-    Lookout::Diff::Groups.
-      new(Lookout::Diff::Operations.
-            new(Lookout::Diff::Algorithms::Difflib.
-                  new('123456789abcdefghijk',
-                      '1i3456789abXdhYjk'))).to_a
-  end
-
-  expect [Lookout::Diff::Group.new(Lookout::Diff::Operations::Insert.new(Lookout::Diff::Range.new(%w[one two three four], 0...0),
-                                                                         Lookout::Diff::Range.new(%w[zero one tree four], 0..0)),
-                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new(%w[one two three four], 0..0),
-                                                                        Lookout::Diff::Range.new(%w[zero one tree four], 1..1)),
-                                   Lookout::Diff::Operations::Replace.new(Lookout::Diff::Range.new(%w[one two three four], 1..2),
-                                                                          Lookout::Diff::Range.new(%w[zero one tree four], 2..2)),
-                                   Lookout::Diff::Operations::Equal.new(Lookout::Diff::Range.new(%w[one two three four], 3..3),
-                                                                        Lookout::Diff::Range.new(%w[zero one tree four], 3..3)))] do
-    Lookout::Diff::Groups.
-      new(Lookout::Diff::Operations.
-            new(Lookout::Diff::Algorithms::Difflib.
-                  new(%w[one two three four],
-                      %w[zero one tree four]))).to_a
-  end
-end