newbamboo-evented-rspec 1.1.12

data/features/mock_framework_integration/use_flexmock.feature

@@ -0,0 +1,27 @@
+Feature: mock with flexmock
+
+  As an RSpec user who prefers flexmock
+  I want to be able to use flexmock without rspec mocks interfering
+
+  Scenario: Mock with flexmock
+    Given the following spec:
+      """
+      Spec::Runner.configure do |config|
+        config.mock_with :flexmock
+      end
+
+      describe "plugging in flexmock" do
+        it "allows flexmock to be used" do
+          target = Object.new
+          flexmock(target).should_receive(:foo).once
+          target.foo
+        end
+
+        it "does not include rspec mocks" do
+          Spec.const_defined?(:Mocks).should be_false
+        end
+      end
+      """
+    When I run it with the spec command
+    Then the exit code should be 0
+    And the stdout should match "2 examples, 0 failures"

data/features/step_definitions/running_rspec.rb

@@ -0,0 +1,54 @@
+Given /^the file (.*)$/ do |relative_path|
+  @path = File.expand_path(File.join(File.dirname(__FILE__), "..", "support", relative_path))
+  unless File.exist?(@path)
+    raise "could not find file at #{@path}"
+  end
+end
+
+Given /^the following spec:$/ do |spec|
+  @path = "/tmp/example_spec.rb"
+  File.open(@path, "w") do |f|
+    f.write spec
+  end
+end
+
+When /^I run it with the (.*)$/ do |interpreter|
+  stderr_file = Tempfile.new('rspec')
+  stderr_file.close
+  @stdout = case(interpreter)
+    when /^ruby interpreter/
+      args = interpreter.gsub('ruby interpreter','')
+      ruby("#{@path}#{args}", stderr_file.path)
+    when /^spec command/
+      args = interpreter.gsub('spec command','')
+      spec("#{@path}#{args}", stderr_file.path)
+    when 'CommandLine object' then cmdline(@path, stderr_file.path)
+    else raise "Unknown interpreter: #{interpreter}"
+  end
+  @stderr = IO.read(stderr_file.path)
+  @exit_code = $?.to_i
+end
+
+Then /^the (.*) should match (.*)$/ do |stream, string_or_regex|
+  written = case(stream)
+    when 'stdout' then @stdout
+    when 'stderr' then @stderr
+    else raise "Unknown stream: #{stream}"
+  end
+  written.should smart_match(string_or_regex)
+end
+
+Then /^the (.*) should not match (.*)$/ do |stream, string_or_regex|
+  written = case(stream)
+    when 'stdout' then @stdout
+    when 'stderr' then @stderr
+    else raise "Unknown stream: #{stream}"
+  end
+  written.should_not smart_match(string_or_regex)
+end
+
+Then /^the exit code should be (\d+)$/ do |exit_code|
+  if @exit_code != exit_code.to_i
+    raise "Did not exit with #{exit_code}, but with #{@exit_code}. Standard error:\n#{@stderr}"
+  end
+end

data/features/support/env.rb

@@ -0,0 +1,26 @@
+require 'tempfile'
+require File.dirname(__FILE__) + '/../../spec/ruby_forker'
+require File.dirname(__FILE__) + '/matchers/smart_match'
+
+$:.push File.join(File.dirname(__FILE__), "/../../lib")
+require 'spec/expectations'
+require 'spec/matchers'
+
+module RspecWorld
+  include Spec::Expectations
+  include Spec::Matchers
+  include RubyForker
+
+  def spec(args, stderr)
+    ruby("#{File.dirname(__FILE__) + '/../../bin/spec'} #{args}", stderr)
+  end
+
+  def cmdline(args, stderr)
+    ruby("#{File.dirname(__FILE__) + '/helpers/cmdline.rb'} #{args}", stderr)
+  end
+end
+
+World do |world|
+  world.extend(RspecWorld)
+  world
+end

data/features/support/helpers/cmdline.rb

@@ -0,0 +1,9 @@
+$:.push File.join(File.dirname(__FILE__), *%w[.. .. .. lib])
+require 'spec'
+
+# Uncommenting next line will break the output feature (no output!!)
+# rspec_options
+options = Spec::Runner::OptionParser.parse(
+  ARGV, $stderr, $stdout
+)
+Spec::Runner::CommandLine.run(options)

data/features/support/matchers/smart_match.rb

@@ -0,0 +1,37 @@
+module Spec
+  module Matchers
+    class SmartMatch
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual
+        # Satisfy expectation here. Return false or raise an error if it's not met.
+
+        if @expected =~ /^\/.*\/?$/ || @expected =~ /^".*"$/
+          regex_or_string = eval(@expected)
+          if Regexp === regex_or_string
+            (@actual =~ regex_or_string) ? true : false
+          else
+            @actual.index(regex_or_string) != nil
+          end
+        else
+          false
+        end
+      end
+
+      def failure_message
+        "expected #{@actual.inspect} to smart_match #{@expected.inspect}, but it didn't"
+      end
+
+      def negative_failure_message
+        "expected #{@actual.inspect} not to smart_match #{@expected.inspect}, but it did"
+      end
+    end
+
+    def smart_match(expected)
+      SmartMatch.new(expected)
+    end
+  end
+end

data/init.rb

@@ -0,0 +1,9 @@
+# Placeholder to satisfy Rails.
+#
+# Do NOT add any require statements to this file. Doing
+# so will cause Rails to load this plugin all of the time.
+#
+# Running 'ruby script/generate rspec' will
+# generate spec/spec_helper.rb, which includes the necessary
+# require statements and configuration. This file should
+# be required by all of your spec files.

data/lib/adapters/mock_frameworks/flexmock.rb

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+#
+#  Created by Jim Weirich on 2007-04-10.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'rubygems'
+require 'flexmock/rspec'
+
+module Spec
+  module Adapters
+    module MockFramework
+      include FlexMock::MockContainer
+      def setup_mocks_for_rspec
+        # No setup required
+      end
+      def verify_mocks_for_rspec
+        flexmock_verify
+      end
+      def teardown_mocks_for_rspec
+        flexmock_close
+      end
+    end
+  end
+end

data/lib/adapters/mock_frameworks/mocha.rb

@@ -0,0 +1,20 @@
+require 'rubygems'
+require 'mocha/standalone'
+require 'mocha/object'
+
+module Spec
+  module Adapters
+    module MockFramework
+      include Mocha::Standalone
+      def setup_mocks_for_rspec
+        mocha_setup
+      end
+      def verify_mocks_for_rspec
+        mocha_verify
+      end
+      def teardown_mocks_for_rspec
+        mocha_teardown
+      end
+    end
+  end
+end

data/lib/adapters/mock_frameworks/rr.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'rr'
+
+patterns = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS
+patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
+
+module Spec
+  module Adapters
+    module MockFramework
+      include RR::Extensions::InstanceMethods
+      def setup_mocks_for_rspec
+        RR::Space.instance.reset
+      end
+      def verify_mocks_for_rspec
+        RR::Space.instance.verify_doubles
+      end
+      def teardown_mocks_for_rspec
+        RR::Space.instance.reset
+      end
+    end
+  end
+end

data/lib/adapters/mock_frameworks/rspec.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec", "mocks"))
+require 'spec/mocks/framework'
+require 'spec/mocks/extensions'
+
+module Spec
+  module Adapters
+    module MockFramework
+      include Spec::Mocks::ExampleMethods
+      def setup_mocks_for_rspec
+        $rspec_mocks ||= Spec::Mocks::Space.new
+      end
+      def verify_mocks_for_rspec
+        $rspec_mocks.verify_all
+      end
+      def teardown_mocks_for_rspec
+        $rspec_mocks.reset_all
+      end
+    end
+  end
+end

data/lib/autotest/discover.rb

@@ -0,0 +1,3 @@
+Autotest.add_discovery do
+  "rspec" if File.directory?('spec') && ENV['RSPEC']
+end

data/lib/autotest/rspec.rb

@@ -0,0 +1,47 @@
+require 'autotest'
+
+Autotest.add_hook :initialize do |at|
+  at.clear_mappings
+  # watch out: Ruby bug (1.8.6):
+  # %r(/) != /\//
+  at.add_mapping(%r%^spec/.*_spec.rb$%) { |filename, _| 
+    filename 
+  }
+  at.add_mapping(%r%^lib/(.*)\.rb$%) { |_, m| 
+    ["spec/#{m[1]}_spec.rb"]
+  }
+  at.add_mapping(%r%^spec/(spec_helper|shared/.*)\.rb$%) { 
+    at.files_matching %r%^spec/.*_spec\.rb$%
+  }
+end
+
+class RspecCommandError < StandardError; end
+
+class Autotest::Rspec < Autotest
+
+  def initialize
+    super
+    self.failed_results_re = /^\d+\)\n(?:\e\[\d*m)?(?:.*?in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m
+    self.completed_re = /\n(?:\e\[\d*m)?\d* examples?/m
+  end
+  
+  def consolidate_failures(failed)
+    filters = new_hash_of_arrays
+    failed.each do |spec, trace|
+      if trace =~ /\n(\.\/)?(.*spec\.rb):[\d]+:/
+        filters[$2] << spec
+      end
+    end
+    return filters
+  end
+
+  def make_test_cmd(files_to_test)
+    return '' if files_to_test.empty?
+    spec_program = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'bin', 'spec'))
+    return "#{ruby} #{spec_program} #{files_to_test.keys.flatten.join(' ')} #{add_options_if_present}"
+  end
+  
+  def add_options_if_present # :nodoc:
+    File.exist?("spec/spec.opts") ? "-O spec/spec.opts " : ""
+  end
+end

data/lib/spec.rb

@@ -0,0 +1,7 @@
+require 'spec/matchers'
+require 'spec/expectations'
+require 'spec/example'
+require 'spec/runner'
+require 'spec/version'
+require 'spec/dsl'
+require 'spec/ruby'

data/lib/spec/dsl.rb

@@ -0,0 +1 @@
+require 'spec/dsl/main'

data/lib/spec/dsl/main.rb

@@ -0,0 +1,87 @@
+module Spec
+  module DSL
+    module Main
+      # Creates and returns a class that includes the ExampleGroupMethods
+      # module. Which ExampleGroup type is created depends on the directory of the file
+      # calling this method. For example, Spec::Rails will use different
+      # classes for specs living in <tt>spec/models</tt>,
+      # <tt>spec/helpers</tt>, <tt>spec/views</tt> and
+      # <tt>spec/controllers</tt>.
+      #
+      # It is also possible to override autodiscovery of the example group
+      # type with an options Hash as the last argument:
+      #
+      #   describe "name", :type => :something_special do ...
+      #
+      # The reason for using different behaviour classes is to have different
+      # matcher methods available from within the <tt>describe</tt> block.
+      #
+      # See Spec::Example::ExampleGroupFactory#register for details about how to
+      # register special implementations.
+      #
+      def describe(*args, &block)
+        Spec::Example::add_spec_path_to(args)
+        Spec::Example::ExampleGroupFactory.assign_scope(self, args)
+        Spec::Example::ExampleGroupFactory.create_example_group(*args, &block)
+      end
+      alias :context :describe
+      
+      # Creates an example group that can be shared by other example groups
+      #
+      # == Examples
+      #
+      #  share_examples_for "All Editions" do
+      #    it "all editions behaviour" ...
+      #  end
+      #
+      #  describe SmallEdition do
+      #    it_should_behave_like "All Editions"
+      #  
+      #    it "should do small edition stuff" do
+      #      ...
+      #    end
+      #  end
+      def share_examples_for(*args, &block)
+        Spec::Example::add_spec_path_to(args)
+        Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block)
+      end
+      alias :shared_examples_for :share_examples_for
+      
+      # Creates a Shared Example Group and assigns it to a constant
+      #
+      #  share_as :AllEditions do
+      #    it "should do all editions stuff" ...
+      #  end
+      #
+      #  describe SmallEdition do
+      #    it_should_behave_like AllEditions
+      #  
+      #    it "should do small edition stuff" do
+      #      ...
+      #    end
+      #  end
+      #
+      # And, for those of you who prefer to use something more like Ruby, you
+      # can just include the module directly
+      #
+      #  describe SmallEdition do
+      #    include AllEditions
+      #  
+      #    it "should do small edition stuff" do
+      #      ...
+      #    end
+      #  end
+      def share_as(name, &block)
+        begin
+          args = [name]
+          Spec::Example::add_spec_path_to(args)
+          Object.const_set(name, Spec::Example::ExampleGroupFactory.create_shared_example_group(*args, &block))
+        rescue NameError => e
+          raise NameError.new(e.message + "\nThe first argument to share_as must be a legal name for a constant\n")
+        end
+      end
+    end
+  end
+end
+
+include Spec::DSL::Main

data/lib/spec/example.rb

@@ -0,0 +1,187 @@
+module Spec
+  # == Example Groups and Code Examples
+  #
+  # A Code Example is an executable example of how a bit of code is expected
+  # to behave.
+  #
+  # An Example Group is a group of code examples.
+  #
+  # RSpec exposes a DSL to describe groups of examples.
+  #  
+  #   describe Account do
+  #     it "should have a balance of $0" do
+  #       account = Account.new
+  #       account.balance.should == Money.new(0, :dollars)
+  #     end
+  #   end
+  #  
+  # == Before and After
+  #  
+  # You can use the <tt>before()</tt> and <tt>after()</tt> methods to extract
+  # common code within an Example Group. Both methods take an optional scope
+  # argument so you can run the block before :each example or before :all
+  # examples
+  #  
+  #   describe "..." do
+  #     before :all do
+  #       ...
+  #     end
+  #  
+  #     before :each do
+  #       ...
+  #     end
+  #  
+  #     it "should do something" do
+  #       ...
+  #     end
+  #  
+  #     it "should do something else" do
+  #       ...
+  #     end
+  #  
+  #     after :each do
+  #       ...
+  #     end
+  #  
+  #     after :all do
+  #       ...
+  #     end
+  #  
+  #   end
+  #  
+  # The <tt>before :each</tt> block will run before each of the examples, once
+  # for each example. Likewise, the <tt>after :each</tt> block will run after
+  # each of the examples.
+  #  
+  # It is also possible to specify a <tt>before :all</tt> and <tt>after
+  # :all</tt> block that will run only once for each example group, before the
+  # first <code>before :each</code> and after the last <code>after
+  # :each</code> respectively. The use of these is generally discouraged,
+  # because it introduces dependencies between the examples. Still, it might
+  # prove useful for very expensive operations if you know what you are doing.
+  #  
+  # == Local helper methods
+  #  
+  # You can include local helper methods by simply expressing them within an
+  # example group:
+  #  
+  #   describe "..." do
+  #    
+  #     it "..." do
+  #       helper_method
+  #     end
+  #  
+  #     def helper_method
+  #       ...
+  #     end
+  #  
+  #   end
+  #  
+  # == Included helper methods
+  #  
+  # You can include helper methods in multiple example groups by expressing
+  # them within a module, and then including that module in your example
+  # groups:
+  #  
+  #   module AccountExampleHelperMethods
+  #     def helper_method
+  #       ...
+  #     end
+  #   end
+  #  
+  #   describe "A new account" do
+  #     include AccountExampleHelperMethods
+  #     before do
+  #       @account = Account.new
+  #     end
+  #  
+  #     it "should have a balance of $0" do
+  #       helper_method
+  #       @account.balance.should eql(Money.new(0, :dollars))
+  #     end
+  #   end
+  #  
+  # == Shared Example Groups
+  #  
+  # You can define a shared example group, that may be used on other groups
+  #
+  #  share_examples_for "All Editions" do
+  #    it "all editions behaviour" ...
+  #  end
+  #
+  #  describe SmallEdition do
+  #    it_should_behave_like "All Editions"
+  #   
+  #    it "should do small edition stuff" do
+  #      ...
+  #    end
+  #  end
+  #
+  # You can also assign the shared group to a module and include that
+  #
+  #  share_as :AllEditions do
+  #    it "should do all editions stuff" ...
+  #  end
+  #
+  #  describe SmallEdition do
+  #    it_should_behave_like AllEditions
+  #   
+  #    it "should do small edition stuff" do
+  #      ...
+  #    end
+  #  end
+  #
+  # And, for those of you who prefer to use something more like Ruby, you can
+  # just include the module directly
+  #
+  #  describe SmallEdition do
+  #    include AllEditions
+  #   
+  #    it "should do small edition stuff" do
+  #      ...
+  #    end
+  #  end
+  module Example
+    class << self
+      def args_and_options(*args) # :nodoc:
+        with_options_from(args) do |options|
+          return args, options
+        end
+      end
+
+      def scope_from(*args) # :nodoc:
+        args[0] || :each
+      end
+
+      def scope_and_options(*args) # :nodoc:
+        args, options = args_and_options(*args)
+        return scope_from(*args), options
+      end
+
+      def add_spec_path_to(args) # :nodoc:
+        args << {} unless Hash === args.last
+        args.last[:spec_path] ||= caller(0)[2]
+      end
+
+    private
+    
+      def with_options_from(args)
+        yield Hash === args.last ? args.pop : {} if block_given?
+      end
+    end
+  end
+end
+
+require 'timeout'
+require 'spec/example/subject'
+require 'spec/example/before_and_after_hooks'
+require 'spec/example/pending'
+require 'spec/example/module_reopening_fix'
+require 'spec/example/example_group_methods'
+require 'spec/example/example_methods'
+require 'spec/example/example_group'
+require 'spec/example/shared_example_group'
+require 'spec/example/example_group_factory'
+require 'spec/example/errors'
+require 'spec/example/example_matcher'
+