rspec 0.0.10 → 0.1.0

data/CHANGES

@@ -0,0 +1,8 @@
+= RSpec Changelog
+
+== Version 0.1.0
+
+This is the first preview release of RSpec, a Behaviour-Driven Development library for Ruby 
+
+* Added Rake script with tasks for gems, rdoc etc.
+* Added an XForge task to make release go easier.

data/README

@@ -0,0 +1,20 @@
+= RSpec - Behaviour Specification Framework for Ruby
+
+RSpec is a behaviour specification framework for Ruby.  RSpec was created in
+response to Dave Astels' article _A New Look at Test Driven Development_ which
+can be read at: http://daveastels.com/index.php?p=5  RSpec is intended to
+provide the features discussed in Dave's article.
+
+RSpec was first explored by Steven Baker <srbaker@pobox.com> and Gabriel
+Bauman <gbauman@gmail.com>, and has since received numerous contributions
+from Dave himself.
+
+== Download/Installation
+
+RSpec is currently being hosted in the Monotone distributed version control system. To checkout RSpec, please download and install Monotone according to the documentation on the monotone website. Then use the following set of commands to grab the latest RSpec sources.
+
+    * monotone --db=database db init
+    * monotone --db=database pull goliath.fundynet.ca org.rubyforge.rspec
+    * monotone --db=database --branch=org.rubyforge.rspec checkout RSpec
+
+Please visit this page periodically, it will be updated with more information as it is made available including documentation, mailing lists, bug tracking, and more. Special thanks to RubyForge for hosting this project site.

data/Rakefile.rb

@@ -0,0 +1,122 @@
+$:.unshift('lib')
+require 'xforge'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+PKG_NAME = "rspec"
+PKG_VERSION = "0.1.0"
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+PKG_FILES = FileList[
+  '[A-Z]*',
+  'lib/**/*.rb', 
+  'doc/**/*'
+]
+
+task :default => [:gem]
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['**/*_test.rb']
+  t.verbose = true
+end
+
+# Create a task to build the RDOC documentation tree.
+rd = Rake::RDocTask.new("rdoc") do |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.title    = "RSpec"
+  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README'
+  rdoc.rdoc_files.include('README', 'CHANGES')
+  rdoc.rdoc_files.include('lib/**/*.rb', 'doc/**/*.rdoc')
+  rdoc.rdoc_files.exclude('doc/**/*_attrs.rdoc')
+end
+
+# ====================================================================
+# Create a task that will package the Rake software into distributable
+# tar, zip and gem files.
+
+spec = Gem::Specification.new do |s|
+
+  #### Basic information.
+
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.summary = "Behaviour Specification Framework for Ruby"
+  s.description = <<-EOF
+    RSpec is a behaviour specification framework for Ruby.  RSpec was created in
+    response to Dave Astels' article _A New Look at Test Driven Development_ which
+    can be read at: http://daveastels.com/index.php?p=5  RSpec is intended to
+    provide the features discussed in Dave's article.
+  EOF
+
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+
+  #### Documentation and testing.
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = rd.rdoc_files.reject { |fn| fn =~ /\.rb$/ }.to_a
+  s.rdoc_options <<
+    '--title' <<  'RSpec' <<
+    '--main' << 'README' <<
+    '--line-numbers'
+
+  #### Author and project details.
+
+  s.author = "Steven Baker" 
+  s.email = "srbaker@pobox.com"
+  s.homepage = "http://rspec.rubyforge.org"
+  s.rubyforge_project = "rspec"
+end
+
+desc "Build Gem"
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+task :gem => [:test]
+
+# Support Tasks ------------------------------------------------------
+
+def egrep(pattern)
+  Dir['**/*.rb'].each do |fn|
+    count = 0
+    open(fn) do |f|
+      while line = f.gets
+        count += 1
+        if line =~ pattern
+          puts "#{fn}:#{count}:#{line}"
+        end
+      end
+    end
+  end
+end
+
+desc "Look for TODO and FIXME tags in the code"
+task :todo do
+  egrep /#.*(FIXME|TODO|TBD)/
+end
+
+task :release => [:publish_doc, :release_files]
+
+task :publish_doc => [:rdoc] do
+  publisher = Rake::RubyForgePublisher.new(PKG_NAME, ENV['RUBYFORGE_USER'])
+  publisher.upload
+end
+
+desc "Release gem to RubyForge. MAKE SURE PKG_VERSION is aligned with the CHANGELOG file"
+task :release_files => [:gem] do
+  release_files = FileList[
+    "pkg/#{PKG_FILE_NAME}.gem"
+  ]
+
+  Rake::XForge::Release.new(PKG_NAME) do |xf|
+    # Never hardcode user name and password in the Rakefile!
+    xf.user_name = ENV['RUBYFORGE_USER']
+    xf.password = ENV['RUBYFORGE_PASSWORD']
+    xf.files = release_files.to_a
+    xf.release_name = "RSpec #{PKG_VERSION}"
+  end
+end

data/lib/rspec.rb

@@ -0,0 +1,9 @@
+class RSpec
+
+  def initialize(args)
+    args.each do |file|
+      require file
+    end
+  end
+
+end

data/lib/spec.rb

@@ -1,30 +1,5 @@
-require 'spec/matchers'
+require 'spec/context'
 require 'spec/expectations'
-require 'spec/example'
-require 'spec/extensions'
-require 'spec/runner'
-require 'spec/adapters'
-
-if Object.const_defined?(:Test)
-  require 'spec/interop/test'
-end
-
-module Spec
-  class << self
-    def run?
-      @run || rspec_options.examples_run?
-    end
-
-    def run
-      return true if run?
-      result = rspec_options.run_examples
-      @run = true
-      result
-    end
-    attr_writer :run
-    
-    def exit?
-      !Object.const_defined?(:Test) || Test::Unit.run?
-    end
-  end
-end
+require 'spec/exceptions'
+require 'spec/text_runner'
+require 'spec/mock'

data/lib/spec/context.rb

@@ -0,0 +1,61 @@
+require 'spec'
+
+
+module Spec
+  class Context
+  
+    def initialize(specification=nil)
+      @specification = specification
+    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, $!)
+      end
+      teardown
+      
+      return result
+    end
+
+    def setup
+    end
+    
+    def teardown
+    end
+
+    def self.collection
+      specs = []
+      self.specifications.each do |spec|
+        specs << self.new(spec.to_sym)
+      end
+      
+      return specs
+    end
+  
+    def self.specifications
+      return self.my_methods.select {|spec| self.specification_name?(spec)}
+    end
+
+    def self.my_methods
+      self.instance_methods - self.superclass.instance_methods
+    end
+
+    def self.specification_name?(name)
+      return false if not self.new.method(name).arity == 0
+      return false if name[0..0] == '_'
+      return true
+    end
+    
+    def violated
+      raise Spec::Exceptions::ExpectationNotMetError.new
+    end
+
+  end
+end

data/lib/spec/{mocks/errors.rb → exceptions.rb}

@@ -1,10 +1,11 @@
 module Spec
-  module Mocks
-    class MockExpectationError < StandardError
+  module Exceptions
+    class ExpectationNotMetError < StandardError
     end
     
-    class AmbiguousReturnError < StandardError
+    class MockExpectationError < StandardError
     end
+    
+    
   end
 end
-

data/lib/spec/expectations.rb

@@ -1,56 +1,67 @@
-require 'spec/matchers'
-require 'spec/expectations/errors'
-require 'spec/expectations/extensions'
-require 'spec/expectations/handler'
-
 module Spec
-  
-  # Spec::Expectations lets you set expectations on your objects.
-  #
-  #   result.should == 37
-  #   team.should have(11).players_on_the_field
-  #
-  # == How Expectations work.
-  #
-  # Spec::Expectations adds two methods to Object:
-  #
-  #   should(matcher=nil)
-  #   should_not(matcher=nil)
-  #
-  # Both methods take an optional Expression Matcher (See Spec::Matchers).
-  #
-  # When +should+ receives an Expression Matcher, it calls <tt>matches?(self)</tt>. If
-  # it returns +true+, the spec passes and execution continues. If it returns
-  # +false+, then the spec fails with the message returned by <tt>matcher.failure_message</tt>.
-  #
-  # Similarly, when +should_not+ receives a matcher, it calls <tt>matches?(self)</tt>. If
-  # it returns +false+, the spec passes and execution continues. If it returns
-  # +true+, then the spec fails with the message returned by <tt>matcher.negative_failure_message</tt>.
-  #
-  # RSpec ships with a standard set of useful matchers, and writing your own
-  # matchers is quite simple. See Spec::Matchers for details.
   module Expectations
-    class << self
-      attr_accessor :differ
-
-      # raises a Spec::Expectations::ExpectationNotMetError with message
-      #
-      # When a differ has been assigned and fail_with is passed
-      # <code>expected</code> and <code>target</code>, passes them
-      # to the differ to append a diff message to the failure message.
-      def fail_with(message, expected=nil, target=nil) # :nodoc:
-        if Array === message && message.length == 3
-          message, expected, target = message[0], message[1], message[2]
-        end
-        unless (differ.nil? || expected.nil? || target.nil?)
-          if expected.is_a?(String)
-            message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected)
-          elsif !target.is_a?(Proc)
-            message << "\nDiff:" << self.differ.diff_as_object(target, expected)
-          end
-        end
-        Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
+
+    def should(message=nil)
+      message ||= "Expectation not met."
+      if (! yield)
+        raise Spec::Exceptions::ExpectationNotMetError.new(message)
       end
     end
+
+    def should_equal(expected, message=nil)
+      message ||= "<#{self}> should be <#{expected}>"
+      should(message) { self.eql?(expected) }
+    end
+
+    def should_not_equal(expected, message=nil)
+      message ||= "<#{self}> should not be <#{expected}>"
+      should(message) { not self.eql?(expected) }
+    end
+
+    def should_be_nil(message=nil)
+      message ||= "<#{self}> should be nil"
+      should(message) { self.nil? }
+    end
+
+    def should_not_be_nil(message=nil)
+      message ||= "<#{self}> should not be nil"
+      should(message) { not self.nil? }
+    end
+
+    def should_be_empty(message=nil)
+      message ||= "<#{self.inspect}> should be empty"
+      should(message) { self.empty? }
+    end
+
+    def should_not_be_empty(message=nil)
+      message ||= "<#{self.inspect}> should not be empty"
+      should(message) { not self.empty? }
+    end
+
+    def should_include(sub, message=nil)
+      message ||= "<#{self.inspect}> should include <#{sub.inspect}>"
+      should(message) { self.include? sub }
+    end
+
+    def should_not_include(sub, message=nil)
+      message ||= "<#{self.inspect}> should not include <#{sub.inspect}>"
+      should(message) { not self.include? sub }
+    end
+    
+    def should_be_true(message=nil)
+      message ||= "<#{self}> should be true"
+      should(message) { self }
+    end
+
+    def should_be_false(message=nil)
+      message ||= "<#{self}> should be false"
+      should(message) { not self }
+    end
   end
+
+end
+
+
+class Object
+  include Spec::Expectations
 end

data/lib/spec/mock.rb

@@ -0,0 +1,104 @@
+require 'spec'
+
+
+class Mock
+
+  def initialize
+    @expectations = Hash.new
+  end
+  
+  def __expects(sym)
+    @expectations[sym] = MockExpectation.new
+    @expectations[sym]
+  end 
+
+  def __verify
+    @expectations.keys.each do |method|
+      @expectations[method].verify(method.to_s) 
+    end
+  end
+  
+  def ignore_missing
+    @ignore_missing = true
+  end
+
+  def method_missing(sym, *args, &block)
+    if expectation = @expectations[sym]
+      expectation.verify_call(sym.to_s,args,block)
+    else
+      begin
+        super(sym, *args, &block) unless @ignore_missing 
+      rescue NoMethodError
+        raise Spec::Exceptions::MockExpectationError, "Unexpected method "+sym.to_s+" called."
+      end
+    end
+  end
+
+end
+
+
+class MockExpectation
+
+  def verify(message)
+    unless @expected_call_count == @call_count
+      raise Spec::Exceptions::MockExpectationError, 
+        message+": Expected #{@expected_call_count} calls, got #{@call_count} calls"
+    end
+  end
+  
+  def verify_call(message,args,block)
+    unless @expected_params == nil or @expected_params == args
+      raise Spec::Exceptions::MockExpectationError,
+        message+": Parameter mismatch: Expected <#{@expected_params}>, got <#{@args}>" 
+    end
+    args << block unless block.nil?
+    @call_count = @call_count + 1
+    @block.call(*args)
+  end
+
+  def initialize
+    @block = proc {}
+    @expected_call_count = 1
+    @call_count = 0
+    @expected_params = nil
+  end
+
+  def with(*args)
+    @expected_params = args
+    self
+  end
+  
+  def with_no_args
+    @expected_params = []
+    self
+  end
+  
+  def with_any_args
+    @expected_params = nill
+    self
+  end
+  
+  def at_least_once
+    self
+  end
+  
+  def never
+    @expected_call_count = 0
+    self
+  end
+  
+  def once
+    @expected_call_count = 1
+    self
+  end
+  
+  def twice
+    @expected_call_count = 2
+    self
+  end
+  
+  def returns(value=nil,&block)
+    @block = block_given? ? block : proc { value }
+  end
+  
+end