lookout 2.0.1

data/lib/lookout/result.rb

@@ -0,0 +1,23 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Result
+  class << self
+    def is(is)
+      [:error, :failure, :fulfilled].each do |type|
+        define_method :"#{type}?" do
+          type == is
+        end
+      end
+    end
+  end
+
+  def initialize(file, line)
+    @file, @line = file, line
+  end
+
+  attr_reader :file, :line
+
+  def to_s
+    '%s:%d' % [file, line]
+  end
+end

data/lib/lookout/results.rb

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Results
+  autoload :Error, 'lookout/results/error'
+  autoload :Failure, 'lookout/results/failure'
+  autoload :Failures, 'lookout/results/failures'
+  autoload :Fulfilled, 'lookout/results/fulfilled'
+
+  include Enumerable
+
+  def initialize
+    @results = []
+  end
+
+  def <<(result)
+    @results << result
+    self
+  end
+
+  def each
+    @results.each do |result|
+      yield result
+    end
+    self
+  end
+
+  def succeeded?
+    all?{ |result| result.fulfilled? }
+  end
+
+  def size
+    @results.size
+  end
+
+  def fulfillments
+    select{ |result| result.fulfilled? }
+  end
+
+  def errors
+    select{ |result| result.error? }
+  end
+
+  def failures
+    select{ |result| result.failure? }
+  end
+end

data/lib/lookout/results/error.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Results::Error < Lookout::Result
+  autoload :Exception, 'lookout/results/error/exception'
+
+  is :error
+
+  def initialize(file, line, message, exception)
+    super file, line
+    @message, @exception = message, Exception.new(exception)
+  end
+
+  attr_reader :message, :exception
+
+  def to_s
+    [super, message, exception].compact.join(': ')
+  end
+end

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

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Results::Error::Exception
+  autoload :Backtrace, 'lookout/results/error/exception/backtrace'
+
+  def initialize(exception)
+    @exception = exception
+  end
+
+  def message
+    # Chomping off a \n here isn’t 100 percent compatible with how Ruby 1.9
+    # does it, but it simplifies the code and also makes the output better if
+    # the message is a lone \n.
+    message = @exception.message.to_str.chomp("\n")
+    if @exception.class == RuntimeError and message.empty?
+      'unhandled exception'
+    elsif message.empty?
+      @exception.class.name
+    elsif @exception.class.name.empty? or @exception.class.name =~ /^#/
+      message
+    else
+      before, newline, after = message.partition("\n")
+      '%s (%s)%s%s' % [before, @exception.class.name, newline, after]
+    end
+  end
+
+  def backtrace
+    @backtrace ||= Backtrace.new(@exception.backtrace)
+  end
+
+  def to_s
+    "%s\n%s" % [message, backtrace]
+  end
+
+  attr_reader :exception
+end

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

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Results::Error::Exception::Backtrace
+  def initialize(backtrace, filter = ENV['LOOKOUT_DO_NOT_FILTER_BACKTRACE'].nil?)
+    @filter = filter
+    @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
+  end
+
+  def to_s
+    backtrace.map{ |location| "\tfrom %s" % location }.join("\n")
+  end
+
+private
+
+  def before
+    nilify(@backtrace.take_while{ |location| not reject? location })
+  end
+
+  def outside
+    nilify(@backtrace.reject{ |location| reject? location })
+  end
+
+  def nilify(backtrace)
+    backtrace.empty? ? nil : backtrace
+  end
+
+  def reject?(location)
+    location.start_with? Root
+  end
+
+  Root = 4.times.reduce(__FILE__){ |path, _| File.dirname(path) }
+end

data/lib/lookout/results/failure.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Results::Failure < Lookout::Result
+  is :failure
+
+  def initialize(file, line, message)
+    super file, line
+    @message = message
+  end
+
+  attr_reader :message
+
+  def to_s
+    [super, message].compact.join(': ')
+  end
+end

data/lib/lookout/results/failures.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Results::Failures
+  autoload :Behavior, 'lookout/results/failures/behavior'
+  autoload :State, 'lookout/results/failures/state'
+end

data/lib/lookout/results/failures/behavior.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Results::Failures::Behavior < Lookout::Results::Failure
+end

data/lib/lookout/results/failures/state.rb

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Results::Failures::State < Lookout::Results::Failure
+end

data/lib/lookout/results/fulfilled.rb

@@ -0,0 +1,9 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Results::Fulfilled < Lookout::Result
+  is :fulfilled
+
+  def initialize(file, line)
+    super file, line
+  end
+end

data/lib/lookout/runners.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Runners
+  autoload :Console, 'lookout/runners/console'
+end

data/lib/lookout/runners/console.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Runners::Console
+  def initialize(expectations = Lookout::Expectations.new)
+    @expectations = expectations
+    @run = true
+  end
+
+  def install
+    at_exit do
+      exit 1 unless @run and @expectations.evaluate.succeeded?
+    end
+    self
+  end
+
+  def expectations_eval(&block)
+    @expectations.instance_eval(&block)
+  rescue
+    @run = false
+    raise
+  end
+end

data/lib/lookout/stub.rb

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Stub
+  autoload :Method, 'lookout/stub/method'
+  autoload :Methods, 'lookout/stub/methods'
+  autoload :Object, 'lookout/stub/object'
+
+  class << self
+    def methods
+      methods = Methods.new
+      yield methods
+    ensure
+      methods.undefine if methods
+    end
+  end
+end

data/lib/lookout/stub/method.rb

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

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

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

data/lib/lookout/ui.rb

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

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::UI::Console < Lookout::UI::Silent
+  def initialize(io = $stdout)
+    @io = io
+  end
+
+  def summarize(results, time)
+    return if results.succeeded?
+    summarize_total results, time
+    summarize_group results, :errors
+    summarize_group results, :failures
+    @io.flush
+  end
+
+private
+
+  def summarize_total(results, time)
+    @io.printf "Ran %d expectations in %.3f seconds: %s\n",
+      results.size,
+      time,
+      [:errors, :failures, :fulfillments].inject([]){ |result, type|
+        next result unless (size = results.send(type).size) > 0
+        result << '%d %s' % [size, type]
+      }.join(', ')
+  end
+
+  def summarize_group(results, type)
+    group = results.send(type)
+    return if group.empty?
+    @io.puts '', type.to_s.upcase, ''
+    group.each do |item|
+      @io.puts item, ''
+    end
+  end
+end