lookout 2.1.4 → 2.2.0

data/lib/lookout.rb

@@ -24,16 +24,7 @@ module Lookout
       return nil, nil unless match = /\A(.*):(\d+)(?::in .*)?\z/.match(location)
       [match[1], match[2].to_i]
     end
-
-    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/diff/algorithms/difflib/position.rb

@@ -9,7 +9,7 @@ class Lookout::Diff::Algorithms::Difflib::Position
       new(Lookout::Diff::Range.new(from),
           to,
           block_given? ?
-            to.indexes.reduce({}){ |j, (k, v)| j[k] = yield(k); j } :
+            to.indexes.reduce({}){ |j, (k, _)| j[k] = yield(k); j } :
             {})
     end
   end

data/lib/lookout/equalities/standarderror.rb

@@ -6,7 +6,7 @@ class Lookout::Equalities::StandardError < Lookout::Equalities::Object
   def equal?(expected, actual)
     expected.equal?(actual) or
       ((actual.respond_to? :message rescue false) and
-       ((Regexp === expected.message and expected.message === actual.message) or
+       ((regexp(expected) and regexp(expected) === actual.message) or
         expected.message == actual.message))
   end
 
@@ -19,8 +19,14 @@ class Lookout::Equalities::StandardError < Lookout::Equalities::Object
 private
 
   def format(expected, actual)
-    Regexp === expected.message ?
-      '%p≠#<%s: %p>' % [actual, expected.class, expected.message] :
+    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/expectations.rb

@@ -2,12 +2,11 @@
 
 class Lookout::Expectations
   autoload :Behavior, 'lookout/expectations/behavior'
+  autoload :Line, 'lookout/expectations/line'
   autoload :State, 'lookout/expectations/state'
 
-  def initialize(results = Lookout::Results::Unsuccessful.new, line = nil)
-    @results, @line = results, line
-    @previous = nil
-    @ran_previous = false
+  def initialize(results = Lookout::Results.new)
+    @results = results
   end
 
   def mock
@@ -39,26 +38,12 @@ class Lookout::Expectations
   end
 
   def expect(expected, &block)
-    expectation = Lookout::Expectation.on(expected, *Lookout.location(caller.first), &block)
-    if @line
-      unless @ran_previous
-        if @previous and @previous.line <= @line and expectation.line > @line
-          @results << @previous.evaluate
-          @ran_previous = true
-          @previous = nil
-        else
-          @previous = expectation
-        end
-      end
-    else
-      @results << expectation.evaluate
-    end
+    @results << Lookout::Expectation.on(expected, *Lookout.location(caller.first), &block).evaluate
     self
   end
 
   # TODO: It would be great if this method wasn’t necessary.
   def flush
-    @results << @previous.evaluate if @previous
     self
   end
 end

data/lib/lookout/expectations/line.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Expectations::Line < Lookout::Expectations
+  def initialize(line, results = Lookout::Results.new)
+    super results
+    @line = line
+    @previous = nil
+    @ran_previous = false
+  end
+
+  def expect(expected)
+    return self if @ran_previous
+    expectation = Lookout::Expectation.on(expected, *Lookout.location(caller.first), &Proc.new)
+    if @previous and @previous.line <= @line and expectation.line > @line
+      flush
+      @previous = nil
+      @ran_previous = true
+    else
+      @previous = expectation
+    end
+    self
+  end
+
+  # TODO: It would be great if this method wasn’t necessary.
+  def flush
+    @results << @previous.evaluate if @previous
+    self
+  end
+end

data/lib/lookout/rake/tasks/gem.rb

@@ -14,7 +14,7 @@ class Lookout::Rake::Tasks::Gem < Rake::TaskLib
   def define
     desc 'Build %s' % specification.file_name
     task :build => specification.file_name
-    file specification.file_name => specification.files do
+    file specification.file_name => [specification.loaded_from] + specification.files do
       when_writing 'Building %s' % specification.file_name do
         require 'rubygems' unless defined? Gem
         require 'rubygems/installer' unless defined? Gem::Builder
@@ -26,7 +26,7 @@ class Lookout::Rake::Tasks::Gem < Rake::TaskLib
     task :check => :build do
       require 'rubygems' unless defined? Gem
       require 'rubygems/installer' unless defined? Gem::Installer
-      checkdir = specification.full_name
+      checkdir = File.join(Lookout::Rake::Tasks.top_srcdir, specification.full_name)
       Gem::Installer.new(specification.file_name, :unpack => true).unpack checkdir
       sh 'rake --rakefile %s/Rakefile -s test' % checkdir
       rm_r checkdir

data/lib/lookout/rake/tasks/test/loader.rb

@@ -2,18 +2,21 @@
 
 require 'lookout'
 
+results = Lookout::Results.new
+line = ENV['LINE'] && ENV['LINE'].to_i
+runner = Lookout::Runners::Console.new(results,
+                                       line ?
+                                         Lookout::Expectations::Line.new(line, results) :
+                                         Lookout::Expectations.new(results),
+                                       Lookout::UI::Console.new(results)).install
 only_load = false
 ARGV.each do |arg|
-  begin
-    if not only_load and arg == '--'
-      only_load = true
-    elsif not only_load and arg =~ /\A-r(.*)/
-      require $1
-    else
-      load arg
-    end
-  rescue SyntaxError => e
-    raise e unless matches = %r{\A(.*?:\d+): (.*)}m.match(e.message)
-    raise SyntaxError, matches[2], [matches[1]]
+  if not only_load and arg == '--'
+    only_load = true
+  elsif not only_load and arg =~ /\A-r(.*)/
+    require $1
+  else
+    runner.load arg
   end
 end
+runner.exit

data/lib/lookout/results.rb

@@ -1,11 +1,25 @@
 # -*- coding: utf-8 -*-
 
-module Lookout::Results
+class Lookout::Results
   autoload :Error, 'lookout/results/error'
   autoload :Failure, 'lookout/results/failure'
   autoload :Failures, 'lookout/results/failures'
   autoload :Fulfilled, 'lookout/results/fulfilled'
-
-  autoload :Instance, 'lookout/results/instance'
   autoload :Unsuccessful, 'lookout/results/unsuccessful'
+
+  def initialize
+    @listeners = []
+  end
+
+  def on_new(&block)
+    @listeners << block
+    self
+  end
+
+  def <<(result)
+    @listeners.each do |listener|
+      listener.call result
+    end
+    self
+  end
 end

data/lib/lookout/results/error/exception.rb

@@ -25,12 +25,10 @@ class Lookout::Results::Error::Exception
   end
 
   def backtrace
-    @backtrace ||= Backtrace.new(@exception.backtrace)
+    @backtrace ||= Backtrace.new(@exception.backtrace, SystemStackError === @exception)
   end
 
   def to_s
     "%s\n%s" % [message, backtrace]
   end
-
-  attr_reader :exception
 end

data/lib/lookout/results/error/exception/backtrace.rb

@@ -1,26 +1,26 @@
 # -*- coding: utf-8 -*-
 
 class Lookout::Results::Error::Exception::Backtrace
-  def initialize(backtrace, filter = ENV['LOOKOUT_DO_NOT_FILTER_BACKTRACE'].nil?)
-    @filter = filter
+  def initialize(backtrace, trim, filter = ENV['LOOKOUT_DO_NOT_FILTER_BACKTRACE'].nil?)
     @backtrace = case backtrace
                  when nil then []
                  when String then [backtrace]
                  when Array then backtrace.select{ |l| String === l }
                  end
-  end
-
-  def backtrace
-    return @backtrace unless @filter
-    before or outside or @backtrace
+    @trim, @filter = trim, filter
   end
 
   def to_s
-    backtrace.map{ |location| "\tfrom %s" % location }.join("\n")
+    trim(backtrace.map{ |location| "\tfrom %s" % location }).join("\n")
   end
 
 private
 
+  def backtrace
+    return @backtrace unless @filter
+    before or outside or @backtrace
+  end
+
   def before
     nilify(@backtrace.take_while{ |location| not reject? location })
   end
@@ -37,5 +37,14 @@ private
     location.start_with? Root
   end
 
+  def trim(locations)
+    return locations unless @trim and locations.length > Head + Tail + 5
+    locations[0...Head] +
+      ["\t ... %d levels ..." % (locations.length - Head - Tail)] +
+      locations[-Tail..-1]
+  end
+
   Root = 4.times.reduce(__FILE__){ |path, _| File.dirname(path) }
+  Head = 8
+  Tail = 5
 end

data/lib/lookout/results/unsuccessful.rb

@@ -1,8 +1,6 @@
 # -*- coding: utf-8 -*-
 
-class Lookout::Results::Unsuccessful
-  include Lookout::Results::Instance
-
+class Lookout::Results::Unsuccessful < Lookout::Results
   include Enumerable
 
   def initialize
@@ -23,10 +21,6 @@ class Lookout::Results::Unsuccessful
     self
   end
 
-  def succeeded?
-    @unsuccessful.empty?
-  end
-
   def errors
     select{ |result| Lookout::Results::Error === result }
   end

data/lib/lookout/runners.rb

@@ -2,4 +2,5 @@
 
 module Lookout::Runners
   autoload :Console, 'lookout/runners/console'
+  autoload :Trackers, 'lookout/runners/trackers'
 end

data/lib/lookout/runners/console.rb

@@ -1,24 +1,41 @@
 # -*- coding: utf-8 -*-
 
 class Lookout::Runners::Console
-  def initialize(results = Lookout::Results::Unsuccessful.new,
-                 expectations = Lookout::Expectations.new(results,
-                                                          ENV['LINE'] && ENV['LINE'].to_i),
+  def initialize(results = Lookout::Results.new,
+                 expectations = Lookout::Expectations.new(results),
                  ui = Lookout::UI::Console.new(results))
     @results, @expectations, @ui = results, expectations, ui
     @ui.start
+    @failed = Lookout::Runners::Trackers::Failure.new(@results)
   end
 
   def install
-    at_exit do
-      next if $!
-      @expectations.flush
-      @ui.summarize
-      exit 1 unless @results.succeeded?
+    Kernel.module_exec(self) do |runner|
+      define_method :Expectations do |&block|
+        runner.expectations_eval(&block)
+      end
     end
     self
   end
 
+  def load(file)
+    expectations_eval do
+      begin
+        load file
+      rescue SyntaxError => e
+        raise unless matches = %r{\A(.*?:\d+): (.*)}m.match(e.message)
+        raise SyntaxError, matches[2], [matches[1]]
+      end
+    end
+  end
+
+  def exit
+    @expectations.flush
+    @ui.flush
+    super 1 if @failed.failed?
+    self
+  end
+
   def expectations_eval(&block)
     @expectations.instance_eval(&block)
   rescue Interrupt, NoMemoryError, SignalException, SystemExit

data/lib/lookout/runners/trackers.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Runners::Trackers
+  autoload :Failure, 'lookout/runners/trackers/failure'
+end

data/lib/lookout/runners/trackers/failure.rb

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Runners::Trackers::Failure
+  def initialize(results)
+    @failed = false
+    results.on_new do |result|
+      @failed = !(Lookout::Results::Fulfilled === result) unless @failed
+    end
+  end
+
+  def failed?
+    @failed
+  end
+end

data/lib/lookout/ui/console.rb

@@ -1,46 +1,19 @@
 # -*- coding: utf-8 -*-
 
 class Lookout::UI::Console
-  def initialize(results, io = $stdout)
+  def initialize(results, io = $stderr)
     @results, @io = results, io
-    @count = 0
-    results.on_new do
-      @count += 1
+    results.on_new do |result|
+      @io.puts result unless Lookout::Results::Fulfilled === result
     end
   end
 
   def start
-    @start = Time.now.to_f
+    self
   end
 
-  def summarize
-    return if @results.succeeded?
-    summarize_total
-    summarize_group :errors
-    summarize_group :failures
+  def flush
     @io.flush
-  end
-
-private
-
-  def summarize_total
-    @io.printf "Ran %d expectations in %.3f seconds: %s\n",
-      @count,
-      Time.now.to_f - @start,
-      [['errors', @results.errors.size],
-       ['failures', @results.failures.size]].tap{ |types|
-        types << ['fulfillments', @count - types.reduce(0){ |sum, pair| sum + pair[1] }]
-      }.select{ |type, size| size > 0 }.
-        map{ |type, size| '%d %s' % [size, type] }.
-        join(', ')
-  end
-
-  def summarize_group(type)
-    group = @results.send(type)
-    return if group.empty?
-    @io.puts '', type.to_s.upcase, ''
-    group.each do |item|
-      @io.puts item, ''
-    end
+    self
   end
 end

data/lib/lookout/ui/silent.rb

@@ -4,6 +4,6 @@ class Lookout::UI::Silent
   def start
   end
 
-  def summarize
+  def flush
   end
 end

data/lib/lookout/version.rb

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

data/test/unit/lookout.rb

@@ -1,10 +1,6 @@
 # -*- coding: utf-8 -*-
 
 Expectations do
-  expect Lookout.runner.to.receive.expectations_eval do
-    Expectations{ }
-  end
-
   expect [nil, nil] do
     Lookout.location('abc')
   end