lookout 2.0.1

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

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method::Calls::Lower
+  extend Lookout::Mock::Method::Calls::Class
+  include Lookout::Mock::Method::Calls::Instance
+
+  format  1,  0, 'expected %s to be called at least once'
+  format  2,  0, 'expected %s to be called at least twice'
+  format  2,  1, 'expected %s to be called at least twice, but was only called once'
+  format(-1, -1, 'expected %s to be called at least %d times, but was only called %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/upper.rb

@@ -0,0 +1,22 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Method::Calls::Upper
+  extend Lookout::Mock::Method::Calls::Class
+  include Lookout::Mock::Method::Calls::Instance
+
+  format  1,  2, 'expected %s to be called at most once, but was called twice'
+  format  1, -1, 'expected %s to be called at most once, but was called %d times'
+  format  2, -1, 'expected %s to be called at most twice, but was called %d times'
+  format(-1, -1, 'expected %s to be called at most %d times, but was called %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/methods.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Methods < Lookout::Stub::Methods
+  def define(object, method, *args, &block)
+    method = Lookout::Mock::Method.new(object, method, *args, &block)
+    raise RuntimeError,
+      '%s: cannot create mock as a mock has already been created: %s' %
+        [method, @methods.first] unless @methods.empty?
+    @methods << method.define
+    method
+  end
+end

data/lib/lookout/mock/object.rb

@@ -0,0 +1,12 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Mock::Object
+  def inspect
+    'mock'
+  end
+
+  def method_missing(method, *args, &block)
+    raise Lookout::Mock::Method::Calls::Error,
+      'unexpected call to %s' % Lookout::Mock::Method.new(self, method)
+  end
+end

data/lib/lookout/object.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+class Object
+  def to
+    Lookout::Recorder.new(self)
+  end
+
+  def not
+    Lookout::Recorder::Not.new(self)
+  end
+end

data/lib/lookout/output.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+require 'stringio'
+
+class Lookout::Output < StringIO
+  def initialize(expected)
+    @expected = expected
+    super()
+  end
+
+  attr_reader :expected
+
+  def actual
+    rewind
+    @actual ||= read
+  end
+
+  def inspect
+    'output(%p)' % expected
+  end
+end

data/lib/lookout/rake/tasks.rb

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+
+require 'rake'
+require 'rake/tasklib'
+
+module Lookout module Rake end end
+
+module Lookout::Rake::Tasks
+  autoload :Gem, 'lookout/rake/tasks/gem'
+  autoload :Tags, 'lookout/rake/tasks/tags'
+  autoload :Test, 'lookout/rake/tasks/test'
+
+  class << self
+    def top_srcdir
+      @top_srcdir ||= Dir.pwd
+    end
+
+    def gemspec
+      @gemspec ||= Dir['%s/*.gemspec' % top_srcdir].first
+    end
+
+    def specification
+      return @specification if defined? @specification
+      return nil unless defined? ::Gem
+      return nil unless gemspec
+      @specification = ::Gem::Specification.load(gemspec)
+    end
+
+    def specification!
+      specification or
+        raise ArgumentError,
+          'gem specification was not given and could not be found in project root: %s' %
+            top_srcdir
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Rake::Tasks::Gem < Rake::TaskLib
+  def initialize(specification = Lookout::Rake::Tasks.specification!)
+    specification or
+      raise ArgumentError,
+        'gem specification was not given and could not be found in project root: %s' %
+          Lookout::Rake::Tasks.top_srcdir
+    @specification = specification
+    yield self if block_given?
+    define
+  end
+
+  def define
+    desc 'Build %s' % specification.file_name
+    task :build => specification.file_name
+    file specification.file_name => specification.files do
+      when_writing 'Building %s' % specification.file_name do
+        require 'rubygems' unless defined? Gem
+        require 'rubygems/installer' unless defined? Gem::Builder
+        Gem::Builder.new(specification).build
+      end
+    end
+
+    desc 'Check %s' % specification.file_name
+    task :check => :build do
+      require 'rubygems' unless defined? Gem
+      require 'rubygems/installer' unless defined? Gem::Installer
+      checkdir = specification.full_name
+      Gem::Installer.new(specification.file_name, :unpack => true).unpack checkdir
+      sh 'rake --rakefile %s/Rakefile -s test' % checkdir
+      rm_r checkdir
+    end
+
+    desc 'Install %s and its dependencies' % specification.file_name
+    task :install do
+      require 'rubygems' unless defined? Gem
+      require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
+      Gem::DependencyInstaller.new.install specification.file_name
+    end
+
+    desc 'Push %s to rubygems.org' % specification.file_name
+    task :push => :check do
+      sh 'gem -%s-verbose push %s' % [verbose ? '' : '-no', specification.file_name]
+    end
+  end
+
+  attr_reader :specification
+end

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

@@ -0,0 +1,16 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Rake::Tasks::Tags < Rake::TaskLib
+  def initialize(specification = Lookout::Rake::Tasks.specification!)
+    @specification = specification
+    yield self if block_given?
+    define
+  end
+
+  def define
+    require 'rbtags/rake/tasks'
+    RbTags::Rake::Tasks::Tags.new specification.require_paths, specification.lib_files.sort
+  end
+
+  attr_reader :specification
+end

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

@@ -0,0 +1,46 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Rake::Tasks::Test < Rake::TaskLib
+  LoaderPath = File.join(File.dirname(__FILE__), 'test/loader.rb')
+
+  def initialize(specification = Lookout::Rake::Tasks.specification, name = :test)
+    self.specification, @name = specification, name
+    yield self if block_given?
+    define
+  end
+
+  def define
+    desc @name == :test ? 'Run tests' : 'Run tests for %s' % @name
+    task @name do
+      ruby '-w %s -- %s %s' % [options, escape(LoaderPath), arguments]
+    end
+
+    task :default => @name unless Rake::Task.task_defined? :default
+  end
+
+  attr_accessor :requires
+
+private
+
+  def specification=(specification)
+    @paths, @requires = specification ?
+      [specification.require_paths, [specification.name]] :
+      [['lib'], []]
+  end
+
+  def options
+    @paths.map{ |p| '-I%s' % p }.join(' ')
+  end
+
+  def arguments
+    requires.map{ |r| '-r%s' % r }.push('--').concat(files).join(' ')
+  end
+
+  def files
+    FileList[ENV.fetch('TEST', 'test/unit/**/*.rb')].map{ |f| escape(f) }
+  end
+
+  def escape(path)
+    path.gsub(/([^A-Za-z0-9_\-.,:\/@\n])/n, '\\\\\\1').gsub(/\n/, "'\n'")
+  end
+end

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

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+require 'lookout'
+
+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]]
+  end
+end

data/lib/lookout/recorder.rb

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Recorder < Lookout::Aphonic
+  autoload :Not, 'lookout/recorder/not'
+  autoload :Tape, 'lookout/recorder/tape'
+
+  def initialize(subject)
+    @subject, @negated = subject, false
+  end
+
+  def not
+    @negated = true
+    self
+  end
+
+  def receive
+    extend Lookout::Recorders::Reception
+    receive!
+  end
+
+  def be
+    extend Lookout::Recorders::State
+    @verb = :be
+    self
+  end
+
+  def have
+    extend Lookout::Recorders::State
+    @verb = :have
+    self
+  end
+
+  def subject!(mocks, stubs)
+    subject
+  end
+
+  attr_reader :subject
+
+  def method_missing(method, *args)
+    return super unless method.to_s =~ /\?$/
+    extend Lookout::Recorders::State
+    @verb = nil
+    method_missing method, *args
+  end
+end

data/lib/lookout/recorder/not.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Recorder::Not < Lookout::Aphonic
+  def initialize(subject)
+    @subject = subject
+  end
+
+  def to
+    @subject.to.not
+  end
+end

data/lib/lookout/recorder/tape.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+
+class Lookout::Recorder::Tape
+  Method = Struct.new(:name, :args)
+
+  def initialize
+    @methods = []
+  end
+
+  def empty?
+    @methods.empty?
+  end
+
+  def record(method, args)
+    @methods << Method.new(method, args)
+  end
+
+  def play_for(subject)
+    @methods.inject(subject){ |result, method| result.send(method.name, *method.args) }
+  end
+end

data/lib/lookout/recorders.rb

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Recorders
+  autoload :Reception, 'lookout/recorders/reception'
+  autoload :State, 'lookout/recorders/state'
+end

data/lib/lookout/recorders/reception.rb

@@ -0,0 +1,47 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Recorders::Reception
+  def subject!(mocks, stubs)
+    @mock = @method._lookout_define(mocks)
+    methods.play_for @mock
+    subject
+  end
+
+  def verify
+    @mock.verify
+  end
+
+private
+
+  def receive!
+    @method = Method.new(self, @negated)
+  end
+
+  def methods
+    @methods ||= Lookout::Recorder::Tape.new
+  end
+
+  def method_missing(method, *args, &block)
+    super unless defined? @method
+    methods.record method, args
+    self
+  end
+
+  class Method < Lookout::Aphonic
+    undef extend
+    undef is_a?
+
+    def initialize(recorder, negated)
+      @recorder, @negated = recorder, negated
+    end
+
+    def method_missing(method, *args, &body)
+      @method, @args, @body = method, args, body
+      @recorder
+    end
+
+    def _lookout_define(mocks)
+      mocks.define(@recorder.subject, @method, *@args, &@body).tap{ |m| m.never if @negated }
+    end
+  end
+end

data/lib/lookout/recorders/state.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+module Lookout::Recorders::State
+  Error = Class.new(StandardError)
+
+  def verify
+    !!methods.play_for(subject) ^ @negated or
+      raise Error,
+        case [@negated, @verb]
+        when [true, :be]    then 'expected %p not to be %s'
+        when [true, :have]  then 'expected %p not to have %s'
+        when [true, nil]    then 'expected %p to %s'
+        when [false, :be]   then 'expected %p to be %s'
+        when [false, :have] then 'expected %p to have %s'
+        when [false, nil]   then 'expected %p to %s'
+        end % [subject, description.join(' ')]
+  end
+
+private
+
+  def methods
+    @methods ||= Lookout::Recorder::Tape.new
+  end
+
+  def description
+    @description ||= []
+  end
+
+  def method_missing(method, *args)
+    description << method.to_s
+    args.each{ |arg| description << arg.inspect }
+    methods.record method, args
+    self
+  end
+end