lookout 2.3.0 → 3.0.0

data/lib/lookout/equalities/warning.rb

@@ -1,16 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Equalities::Warning < Lookout::Equalities::String
-  Lookout::Equality.register self, Lookout::Warning
-
-  def equal?(expected, actual)
-    expected == actual.chomp or
-      actual =~ /\A.*?:\d+: warning: #{Regexp.escape(expected)}\Z/u
-  end
-
-private
-
-  def format(expected, actual)
-    '%p≠%p' % [Lookout::Warning.new(actual), expected]
-  end
-end

data/lib/lookout/equality.rb

@@ -1,36 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Lookout::Equality
-  class << self
-    def register(equality, *types)
-      eq = equality.new
-      types.each do |type|
-        equalities[type] = eq
-      end
-    end
-
-    def equal?(expected, actual)
-      self[expected].equal? expected, actual
-    end
-
-    def message(expected, actual)
-      self[expected].message expected, actual
-    end
-
-    def diff(expected, actual)
-      self[expected].diff expected, actual
-    end
-
-  private
-
-    def [](expected)
-      equalities[expected.class.ancestors.find{ |type| equalities[type] }]
-    end
-
-    def equalities
-      @equalities ||= {}
-    end
-  end
-
-  require 'lookout/equalities'
-end

data/lib/lookout/expectation.rb

@@ -1,69 +0,0 @@
-# -*- coding: utf-8 -*-
-
-module Lookout::Expectation
-  def self.on(expected, file, line, &block)
-    case expected
-    when Lookout::Recorder
-      Lookout::Expectations::Behavior
-    when Lookout::Warning
-      Lookout::Expectations::State::Warning
-    else
-      Lookout::Expectations::State
-    end.new(expected, file, line, &block)
-  end
-
-  def initialize(expected, file, line, &block)
-    @expected, @file, @line, @block = expected, file, line, 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|
-          if value.respond_to? :to_proc
-            @stubs.define(stub, name, &value)
-          else
-            @stubs.define(stub, name){ value }
-          end
-        end
-      }
-    else
-      Method.new(@stubs, args[0])
-    end
-  end
-
-  def with_verbose(verbose = true)
-    saved_verbose = $VERBOSE
-    $VERBOSE = verbose
-    begin
-      yield
-    ensure
-      $VERBOSE = saved_verbose
-    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

@@ -1,49 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Expectations
-  autoload :Behavior, 'lookout/expectations/behavior'
-  autoload :Line, 'lookout/expectations/line'
-  autoload :State, 'lookout/expectations/state'
-
-  def initialize(results = Lookout::Results.new)
-    @results = results
-  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 warning(string)
-    Lookout::Warning.new(string)
-  end
-
-  def xml(string)
-    Lookout::XML.new(string)
-  end
-
-  def expect(expected, &block)
-    @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
-    self
-  end
-end

data/lib/lookout/expectations/behavior.rb

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

@@ -1,29 +0,0 @@
-# -*- 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/expectations/state.rb

@@ -1,31 +0,0 @@
-# -*- coding: utf-8 -*-
-
-class Lookout::Expectations::State
-  autoload :Warning, 'lookout/expectations/state/warning'
-
-  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/expectations/state/warning.rb

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-
-require 'stringio'
-
-class Lookout::Expectations::State::Warning < Lookout::Expectations::State
-  def evaluate_with_stubs
-    @output = StringIO.new
-    saved_stderr = $stderr
-    $stderr = @output
-    begin
-      with_verbose do
-        super
-      end
-    ensure
-      $stderr = saved_stderr
-    end
-  end
-
-private
-
-  def check(actual)
-    @output.rewind
-
-    super @output.read
-  end
-end

data/lib/lookout/mock.rb

@@ -1,20 +0,0 @@
-# -*- 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
-      begin
-        yield methods
-      ensure
-        methods.undefine
-      end
-    end
-  end
-end

data/lib/lookout/mock/method.rb

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

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

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

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

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