rspec 0.4.0 → 0.5.0

data/examples/movie_spec.rb

@@ -1,37 +0,0 @@
-require 'spec'
-require 'movie'
-require 'movie_list'
-
-class EmptyMovieList < Spec::Context
-
-  def setup
-    @list = MovieList.new
-  end
-    
-  def should_have_size_of_0
-    @list.size.should.equal 0
-  end
-  
-  def should_not_include_star_wars
-    @list.should.not.include "Star Wars"
-  end
-  
-end
-
-class OneMovieList < Spec::Context
-
-  def setup
-    @list = MovieList.new
-    star_wars = Movie.new "Star Wars"
-    @list.add star_wars
-  end
-  
-  def should_have_size_of_1
-    @list.size.should.equal 1
-  end
-  
-  def should_include_star_wars
-    @list.should.include "Star Wars"
-  end
-  
-end

data/lib/spec/collector.rb

@@ -1,17 +0,0 @@
-require 'spec'
-
-
-module Spec
-	class Collector
-
-		def self.collection
-			collection = []
-			ObjectSpace.each_object(Class) do |cls|
-				collection << cls.collection if cls < Spec::Context
-			end
-			collection.flatten
-		end
-
-	end
-end
-

data/lib/spec/context.rb

@@ -1,89 +0,0 @@
-require 'spec'
-
-module Spec
-  # TODO: Could we try to make this a mixin (Module) instead? It would make it easier to
-  # create extensions that can be mixed and matched (AH).
-  class Context
-  
-    def initialize(specification=nil)
-      @specification = specification
-      @mocks = []
-    end
-
-    def setup
-    end
-
-    def teardown
-    end
-    
-    # Creates a new named mock that will be automatically verified after #teardown
-    # has run. By using this method instead of Mock#new you don't have to worry about
-    # forgetting to verify your mocks.
-    def mock(name)
-      mock = Mock.new(name)
-      @mocks << mock
-      mock
-    end
-
-    # Immediately violates the current specification with +message+.
-    def violated(message="")
-      raise Spec::Exceptions::ExpectationNotMetError.new(message)
-    end
-
-    def self.collection
-      specs = []
-      self.specifications.each do |spec|
-        specs << self.new(spec.to_sym)
-      end
-
-      return specs
-    end
-
-    def run(result_listener)
-      result = false
-
-      result_listener.spec(@specification)
-      setup
-      begin
-        __send__(@specification)
-        result_listener.pass(@specification)
-      rescue Exception
-        result_listener.failure(@specification, $!)
-      ensure
-        begin
-          teardown
-          verify_mocks
-        rescue Exception
-          result_listener.failure(@specification, $!)
-        end
-      end
-
-      return result
-    end
-
-    def self.add_specification(name, &block)
-      self.send(:define_method, name.to_sym, Proc.new { || block.call })
-    end
-
-  private
-  
-    def self.my_methods
-      self.instance_methods - self.superclass.instance_methods
-    end
-
-    def self.specification_name?(name)
-      return false unless self.new.method(name).arity == 0
-      return false if name[0..0] == '_'
-      true
-    end
-
-    def self.specifications
-      return self.my_methods.select {|spec| self.specification_name?(spec)}
-    end
-
-    def verify_mocks
-      @mocks.each{|m| m.__verify}
-    end
-
-  end
-end

data/lib/spec/dsl.rb

@@ -1,23 +0,0 @@
-require 'spec'
-
-module DSLExtensions
-
-  def context(name)
-    eval "$#{name} = Class.new(Spec::Context)"
-    $current_context = eval "$#{name}"
-  end
-
-  def specification(name, &block)
-    $default_context ||= Class.new(Spec::Context)
-    $current_context = $default_context if $current_context.nil?
-
-    $current_context.add_specification(name.to_sym, &block)
-  end
-
-end
-
-class Object
-  include DSLExtensions
-end
-
-alias example specification if ENV['USER'] == 'marick'

data/lib/spec/gui_runner.rb

@@ -1,59 +0,0 @@
-require 'socket' 
-@socket
-module Spec
-  class GuiRunner
- 
-    def initialize(port)
-      @failures = Array.new
-      @specification_count = 0
-      @failure_count = 0
-      @failed = false
-      @socket = TCPSocket.new("127.0.0.1", port)
-			@socket << "connected\n"
-    end
-
-    def run(context_or_collection = Spec::Collector)
-			specs = context_or_collection.collection
-      start_run specs.size
-      specs.each {|spec| spec.run(self)}
-      end_run
-			@socket.shutdown
-    end
-
-    def spec(spec)
-      @failed = false
-    end
-  
-    def pass(spec)
-      @socket << "passed\n"
-    end
-
-    def failure(spec, exception)
-			return if @failed
-      @socket << "failed\n"
-      @failed = true
-      dump_failure(exception)
-    end
-  
-    def start_run(number_of_specs)
-      @socket << "start #{number_of_specs.to_i}\n"
-    end
-  
-    def end_run
-      @socket << "end\n"
-    end    
-
-    def dump_failure(exception)
-   		@socket << "#{exception.message} (#{exception.class.name})\n"
-      dump_backtrace(exception.backtrace)
-			@socket << "!\n"
-    end
-
-    def dump_backtrace(trace)
-    	lines = trace.reject {|line| line.include? "lib/spec"}.reject {|line | line.include? "./spec:"}
-      @socket << lines.join("\n")
-			@socket << "\n"
-    end
-    
-  end
-end

data/lib/spec/mock.rb

@@ -1,183 +0,0 @@
-require 'spec'
-
-class Mock
-
-  DEFAULT_OPTIONS = {
-    :null_object => false
-  }
-  # Creates a new mock with a +name+ (that will be used in error messages only)
-  # Options:
-  # * :null_object - if true, the mock object acts as a forgiving null object allowing any message to be sent to it.
-  def initialize(name, options={})
-    @name = name
-    @options = DEFAULT_OPTIONS.dup.merge(options)
-    @expectations = []
-  end
-
-  # AH: How about renaming this to should_receive. This would be:
-  #   * well aligned with the rest of the API (should)
-  #   * emphasize the dynamic oo lingo from smalltalk using 'message' instead of 'method' 
-  def should_receive(sym, &block)
-    expected_from = caller(1)[0]
-    expectation = MessageExpectation.new(@name, expected_from, sym, block_given? ? block : nil)
-    @expectations << expectation
-    expectation
-  end
-
-  def __verify
-    @expectations.each do |expectation|
-      expectation.verify_messages_received
-    end
-  end
-
-  def method_missing(sym, *args, &block)
-    # TODO: use find_expectation(sym, args) which will lookup based on sym, args and strict mode.
-    if expectation = find_matching_expectation(sym, *args)
-      expectation.verify_message(args, block)
-    else
-      begin
-        # act as null object if method is missing and we ignore them. return value too!
-        @options[:null_object] ? self : super(sym, *args, &block)
-      rescue NoMethodError
-        raise Spec::Exceptions::MockExpectationError, "Mock '#{@name}' received unexpected message '#{sym.to_s}' with " + (args.collect{|arg| "<#{arg}:#{arg.class.name}>"}.join(", "))
-      end
-    end
-  end
-
-private
-
-  def find_matching_expectation(sym, *args)
-    expectation = @expectations.find {|expectation| expectation.matches(sym, args)}
-  end
-
-end
-
-# Represents the expection of the reception of a message
-class MessageExpectation
-
-  def initialize(mock_name, expected_from, sym, block)
-    @mock_name = mock_name
-    @expected_from = expected_from
-    @sym = sym
-    @method_block = block
-    @block = proc {}
-    @received_count = 0
-    @expected_received_count = 1
-    @expected_params = nil
-    @consecutive = false
-  end
-  
-  def matches(sym, args)
-    @sym == sym and (@expected_params.nil? or @expected_params == args)
-  end
-
-  # This method is called at the end of a spec, after teardown.
-  def verify_messages_received
-    # TODO: this doesn't provide good enough error messages to fix the error.
-    # Error msg should tell exactly what went wrong. (AH).
-    
-    return if @expected_received_count == -2
-    return if (@expected_received_count == -1) && (@received_count > 0)
-    return if @expected_received_count == @received_count
-    
-    expected_signature = nil
-    if @expected_params.nil?
-      expected_signature = @sym
-    else
-      params = @expected_params.collect{|param| "<#{param}:#{param.class.name}>"}.join(", ")
-      expected_signature = "#{@sym}(#{params})"
-    end
-    
-    count_message = "{@expected_received_count} times"
-    count_message = "at least once" if (@expected_received_count == -1)
-    count_message = "never" if (@expected_received_count == 0)
-    count_message = "once" if (@expected_received_count == 1)
-    count_message = "twice" if (@expected_received_count == 2)
-
-    message = "#{@expected_from}: Mock '#{@mock_name}' expected #{expected_signature} #{count_message}, but received it #{@received_count} times"
-      raise Spec::Exceptions::MockExpectationError, message
-  end
-
-  # This method is called when a method is invoked on a mock
-  def verify_message(args, block)
-    unless @method_block.nil?
-      begin
-        result = @method_block.call(*args)
-      rescue Spec::Exceptions::ExpectationNotMetError => detail
-        raise Spec::Exceptions::MockExpectationError, "Call expectation violated with: " + $!
-      end
-      @received_count += 1
-      return result
-    end
-    
-    unless @expected_params.nil? or @expected_params == args
-      raise Spec::Exceptions::MockExpectationError,
-        "#{@sym}: Parameter mismatch: Expected <#{@expected_params}>, got <#{args}>" 
-    end
-    args << block unless block.nil?
-    @received_count += 1
-    value = @block.call(*args)
-    
-    return value unless @consecutive
-    
-    value[[@received_count, value.size].min - 1]
-  end
-
-  def with(*args)
-    @expected_params = args
-    self
-  end
-
-  def with_no_args
-    @expected_params = []
-    self
-  end
-  
-  def with_any_args
-    @expected_params = nil
-    self
-  end
-  
-  def at_least_once
-    @expected_received_count = -1
-    self
-  end
-
-   def any_number_of_times
-     @expected_received_count = -2
-     self
-   end
-  
-  def never
-    @expected_received_count = 0
-    self
-  end
-  
-  def once
-    @expected_received_count = 1
-    self
-  end
-  
-  def twice
-    @expected_received_count = 2
-    self
-  end
-  
-  def returns(value=nil,&block)
-    @block = block_given? ? block : proc { value }
-  end
-
-  def returns_consecutively(value=[nil],&block)
-    @consecutive = true
-    @block = block_given? ? block : proc { value }
-  end
-  
-  # this reads better in English IMHO: (AH)
-  # uri_specs.should_receive(:[]).with(:overview).and_return("http://some.host/look_here/\#{path}")
-  alias :and_return :returns
-  alias :and_return_consecutively :returns_consecutively
-  
-end
-
-class Counter
-end

data/lib/spec/text_runner.rb

@@ -1,75 +0,0 @@
-module Spec
-  class TextRunner
- 
-    def initialize(appendable = $stdout)
-      @failures = Array.new
-      @specification_count = 0
-      @failure_count = 0
-      @failed = false
-      @output = appendable
-    end
-
-    def run(context_or_collection = Spec::Collector)
-      start_run
-      context_or_collection.collection.each {|context| context.run(self)}
-      end_run
-    end
-
-    def spec(spec)
-      @specification_count += 1
-      @failed = false
-    end
-  
-    def pass(spec)
-      @output << "."
-    end
-
-    def failure(spec, exception)
-      @output << "X" unless @failed
-      @failure_count += 1 unless @failed
-      @failed = true
-      @failures << exception
-    end
-  
-    def start_run
-      @output << "\n"
-      @start_time = Time.new
-    end
-  
-    def end_run
-      @end_time = Time.new
-      @output << "\n\n"
-
-      dump_failures
-      
-      dump_duration(@end_time - @start_time)
-      
-      dump_counts
-    end    
-
-    def dump_failures
-      @failures.inject(1) do |index, exception|
-        @output << index.to_s << ")\n" 
-        @output << "#{exception.message} (#{exception.class.name})\n"
-        dump_backtrace(exception.backtrace)
-        index + 1
-      end
-    end
-
-    def dump_backtrace(trace)
-      lines = trace.reject {|line| line.include? "lib/spec"}.reject {|line | line.include? "./spec:"}
-      @output << lines.join("\n")
-      @output << "\n\n"
-    end
-    
-    def dump_duration(duration)
-      @output << "Finished in " << duration.to_s << " seconds\n"
-    end
-    
-    def dump_counts
-      @output << "\n" << @specification_count.to_s << " specifications, "
-      @output << @failure_count.to_s << " failures\n"
-    end
-    
-  end
-end