lookout 2.0.1

data/lib/lookout/expectation.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Expectation
+  def self.on(expected, file, line, &block)
+    (expected.is_a?(Lookout::Recorder) ?
+     Lookout::Expectations::Behavior :
+     Lookout::Expectations::State).new(expected, file, line, &block)
+  end
+
+  def initialize(expected, file, line, &block)
+    @expected, @file, @line, @block = expected, file, line.to_i, block
+  end
+
+  def evaluate
+    Lookout::Stub.methods{ |stubs| @stubs = stubs; evaluate_with_stubs }.tap{ @stubs = nil }
+  end
+
+  def stub(*args)
+    raise ArgumentError,
+      'wrong number of arguments (%d for 1)' % args.length unless args.count < 2
+    return Lookout::Stub::Object.new if args.length < 1
+    case args[0]
+    when Hash
+      Lookout::Stub::Object.new.tap{ |stub|
+        args[0].each do |name, value|
+          @stubs.define(stub, name){ value }
+        end
+      }
+    else
+      Method.new(@stubs, args[0])
+    end
+  end
+
+  attr_reader :file, :line
+
+private
+
+  class Method < Lookout::Aphonic
+    undef extend
+    undef is_a?
+
+    def initialize(stubs, object)
+      @stubs, @object = stubs, object
+    end
+
+    def method_missing(method, &body)
+      @stubs.define(@object, method, &body)
+    end
+  end
+end

data/lib/lookout/expectations.rb

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Expectations
+  autoload :Behavior, 'lookout/expectations/behavior'
+  autoload :State, 'lookout/expectations/state'
+
+  include Enumerable
+
+  def initialize
+    @expectations = []
+  end
+
+  def mock
+    Lookout::Mock::Object.new
+  end
+
+  def arg
+    Lookout::Mock::Method::Arguments::Anything.new
+  end
+
+  def without_arguments
+    Lookout::Mock::Method::Arguments::None.new
+  end
+
+  def stub
+    Lookout::Stub::Object.new
+  end
+
+  def output(string)
+    Lookout::Output.new(string)
+  end
+
+  def xml(string)
+    Lookout::XML.new(string)
+  end
+
+  def expect(expected, &block)
+    file, line = /\A(.*):(\d+)(?::in .*)?\z/.match(caller.first)[1..2]
+    @expectations << Lookout::Expectation.on(expected, file, line, &block)
+    expected
+  end
+
+  def evaluate(ui = Lookout::UI::Console.new, results = Lookout::Results.new)
+    ui.start
+    ui.summarize results, Lookout::Benchmark.time{
+      each(ENV['LINE'] ? ENV['LINE'].to_i : nil) do |expectation|
+        results << expectation.evaluate.tap{ |result| ui.report result }
+      end
+    }
+    results
+  end
+
+  def each(line = nil)
+    return enum_for(:each, line) unless block_given?
+    (line ?
+     Array(@expectations.reverse.find{ |e| e.line <= line }) :
+     @expectations).each do |expectation|
+      yield expectation
+    end
+    self
+  end
+end

data/lib/lookout/expectations/behavior.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Expectations::Behavior
+  include Lookout::Expectation
+
+  def evaluate_with_stubs
+    Lookout::Mock.methods do |mocks|
+      @expected.subject! mocks, @stubs
+      instance_exec @expected.subject, &@block if @block
+      @expected.verify
+    end
+    Lookout::Results::Fulfilled.new(file, line)
+  rescue Lookout::Recorders::State::Error => e
+    Lookout::Results::Failures::State.new(file, line, e.message)
+  rescue Lookout::Mock::Error => e
+    Lookout::Results::Failures::Behavior.new(file, line, e.message)
+  rescue Exception => e
+    Lookout::Results::Error.new(file, line, nil, e)
+  end
+end

data/lib/lookout/expectations/state.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Expectations::State
+  include Lookout::Expectation
+
+  def evaluate_with_stubs
+    check(@block ? instance_exec(@expected, &@block) : false)
+  rescue Exception => e
+    return check(e) if StandardError === @expected and @expected.class == e.class
+    return Lookout::Results::Fulfilled.new(file, line) if @expected.eql? e.class
+    Lookout::Results::Error.new(file, line,
+      if Class === @expected and StandardError >= @expected
+        Lookout::Equality.message(@expected, e.class)
+      elsif StandardError === @expected
+        Lookout::Equality.message(@expected.class, e.class)
+      else
+        nil
+      end,
+      e)
+  end
+
+private
+
+  def check(actual)
+    (@expected == actual or Lookout::Equality.equal? @expected, actual) ?
+      Lookout::Results::Fulfilled.new(file, line) :
+      Lookout::Results::Failures::State.new(file, line, Lookout::Equality.message(@expected, actual))
+  end
+end

data/lib/lookout/mock.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Mock
+  autoload :Method, 'lookout/mock/method'
+  autoload :Methods, 'lookout/mock/methods'
+  autoload :Object, 'lookout/mock/object'
+
+  Error = Class.new(StandardError)
+
+  class << self
+    def methods
+      methods = Methods.new
+      yield methods
+    ensure
+      methods.undefine if methods
+    end
+  end
+end

data/lib/lookout/mock/method.rb

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method < Lookout::Stub::Method
+  autoload :Arguments, 'lookout/mock/method/arguments'
+  autoload :Calls, 'lookout/mock/method/calls'
+
+  def initialize(object, method, *args, &body)
+    super object, method, &body
+    @args = Arguments.new(*args)
+    at_least_once
+  end
+
+  def never
+    exactly(0)
+  end
+
+  def at_most_once
+    at_most(1)
+  end
+
+  def once
+    exactly(1)
+  end
+
+  def at_least_once
+    at_least(1)
+  end
+
+  def twice
+    exactly(2)
+  end
+
+  def at_most(times)
+    @calls = Calls::Upper.new(self, times)
+    self
+  end
+
+  def exactly(times)
+    @calls = Calls::Exactly.new(self, times)
+    self
+  end
+
+  def at_least(times)
+    @calls = Calls::Lower.new(self, times)
+    self
+  end
+
+  def call(*args, &block)
+    @calls.call
+    @args.verify(*args)
+    super
+  rescue Lookout::Mock::Error => e
+    raise e, '%s: %s' % [self, e]
+  end
+
+  def verify
+    @calls.verify
+    self
+  end
+
+  def to_s
+    '%p.%s%p' % [@object, @method, @args]
+  end
+
+private
+
+  def stash
+    :"__mocked_method_#{@method}"
+  end
+end

data/lib/lookout/mock/method/arguments.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method::Arguments
+  autoload :Any, 'lookout/mock/method/arguments/any'
+  autoload :Anything, 'lookout/mock/method/arguments/anything'
+  autoload :List, 'lookout/mock/method/arguments/list'
+  autoload :None, 'lookout/mock/method/arguments/none'
+
+  Error = Class.new(Lookout::Mock::Error)
+
+  def initialize(*args)
+    self.args = args
+  end
+
+  def verify(*args)
+    @args == args or
+      raise Error, 'unexpected arguments: (%s)≠(%p)' %
+        [args.map{ |arg| arg.inspect }.join(', '), @args]
+  end
+
+  def inspect
+    result = @args.inspect
+    result.empty? ? "" : '(%s)' % result
+  end
+
+protected
+
+  def args=(args)
+    return @args = Any.new if args.empty?
+    none = args.find{ |arg| arg.is_a? None } and return @args = none
+    @args = List.new(args)
+  end
+end

data/lib/lookout/mock/method/arguments/any.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method::Arguments::Any
+  def ==(other)
+    true
+  end
+
+  def inspect
+    '*args, &block'
+  end
+end

data/lib/lookout/mock/method/arguments/anything.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method::Arguments::Anything
+  def ==(other)
+    true
+  end
+
+  def inspect
+    'arg'
+  end
+end

data/lib/lookout/mock/method/arguments/list.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method::Arguments::List
+  def initialize(args)
+    @args = args
+  end
+
+  def ==(other)
+    Lookout::Equality.equal?(@args, other)
+  end
+
+  def inspect
+    @args.map{ |arg| arg.inspect }.join(', ')
+  end
+end

data/lib/lookout/mock/method/arguments/none.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method::Arguments::None
+  def ==(other)
+    other.empty?
+  end
+
+  def inspect
+    ""
+  end
+end

data/lib/lookout/mock/method/arguments/one.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method::Arguments::Any
+  def ==(other)
+    other.count == 1
+  end
+
+  def inspect
+    'arg'
+  end
+end

data/lib/lookout/mock/method/calls.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Mock::Method::Calls
+  autoload :Class, 'lookout/mock/method/calls/class'
+  autoload :Exactly, 'lookout/mock/method/calls/exactly'
+  autoload :Instance, 'lookout/mock/method/calls/instance'
+  autoload :Lower, 'lookout/mock/method/calls/lower'
+  autoload :Upper, 'lookout/mock/method/calls/upper'
+
+  Error = ::Class.new(Lookout::Mock::Error)
+end

data/lib/lookout/mock/method/calls/class.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Mock::Method::Calls::Class
+  def format(limit, calls, format = nil)
+    return formats[limit][calls] unless format
+    if limit == -1
+      formats.default = Hash.new([format, [:@method, :@expected, :@calls]])
+    elsif calls == -1
+      formats[limit].default = [format, [:@method, :@calls]]
+    else
+      formats[limit][calls] = [format, [:@method]]
+    end
+    self
+  end
+
+private
+
+  def formats
+    @formats ||= Hash.new{ |hash, key| hash[key] = {} }
+  end
+end

data/lib/lookout/mock/method/calls/exactly.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method::Calls::Exactly
+  extend Lookout::Mock::Method::Calls::Class
+  include Lookout::Mock::Method::Calls::Instance
+
+  format  0,  1, 'expected %s not to be called'
+  format  0,  2, 'expected %s not to be called, but was called twice'
+  format  0, -1, 'expected %s not to be called, but was called %d times'
+  format  1,  0, 'expected %s to be called'
+  format  1,  2, 'expected %s to be called once, not twice'
+  format  1, -1, 'expected %s to be called once, not %d times'
+  format  2,  0, 'expected %s to be called twice'
+  format  2,  1, 'expected %s to be called twice, but was only called once'
+  format  2, -1, 'expected %s to be called twice, not %d times'
+  format(-1, -1, 'expected %s to be called %d times, not %d times')
+
+  def initialize(method, limit)
+    raise ArgumentError, 'limit must be >= 0' unless limit >= 0
+    super
+  end
+
+private
+
+  def satisfied?
+    @calls == @limit
+  end
+end

data/lib/lookout/mock/method/calls/instance.rb

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Mock::Method::Calls::Instance
+  def initialize(method, limit)
+    @method, @limit = method, limit
+    @calls = 0
+  end
+
+  def call
+    @calls += 1
+    self
+  end
+
+  def verify
+    raise Lookout::Mock::Method::Calls::Error, message unless satisfied?
+    self
+  end
+
+private
+
+  def message
+    format, variables = self.class.format(@limit, @calls)
+    format % variables.map{ |v| instance_variable_get(v) }
+  end
+end