rspec-core 2.0.0.a1

data/features/mock_framework_integration/use_flexmock.feature

@@ -0,0 +1,23 @@
+Feature: mock with flexmock
+
+  As an RSpec user who likes to mock
+  I want to be able to use flexmock
+
+  Scenario: Mock with flexmock
+    Given a file named "flexmock_example_spec.rb" with:
+      """
+      Rspec::Core.configure do |config|
+        config.mock_framework = :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
+      end
+      """
+    When I run "spec flexmock_example_spec.rb"
+    Then the stdout should match "1 example, 0 failures" 
+    And the exit code should be 0

data/features/mock_framework_integration/use_mocha.feature

@@ -0,0 +1,23 @@
+Feature: mock with mocha
+
+  As an RSpec user who likes to mock
+  I want to be able to use mocha
+
+  Scenario: Mock with mocha
+    Given a file named "mocha_example_spec.rb" with:
+      """
+      Rspec::Core.configure do |config|
+        config.mock_framework = :mocha
+      end
+
+      describe "plugging in mocha" do
+        it "allows mocha to be used" do
+          target = Object.new
+          target.expects(:foo).once
+          target.foo
+        end
+      end
+      """
+    When I run "spec mocha_example_spec.rb"
+    Then the stdout should match "1 example, 0 failures" 
+    And the exit code should be 0

data/features/mock_framework_integration/use_rr.feature

@@ -0,0 +1,23 @@
+Feature: mock with rr
+
+  As an RSpec user who likes to mock
+  I want to be able to use rr
+
+  Scenario: Mock with rr
+    Given a file named "rr_example_spec.rb" with:
+      """
+      Rspec::Core.configure do |config|
+        config.mock_framework = :rr
+      end
+
+      describe "plugging in rr" do
+        it "allows rr to be used" do
+          target = Object.new
+          mock(target).foo
+          target.foo
+        end
+      end
+      """
+    When I run "spec rr_example_spec.rb"
+    Then the stdout should match "1 example, 0 failures" 
+    And the exit code should be 0

data/features/mock_framework_integration/use_rspec.feature

@@ -0,0 +1,23 @@
+Feature: mock with rspec
+
+  As an RSpec user who likes to mock
+  I want to be able to use rspec
+
+  Scenario: Mock with rspec
+    Given a file named "rspec_example_spec.rb" with:
+      """
+      Rspec::Core.configure do |config|
+        config.mock_framework = :rspec
+      end
+
+      describe "plugging in rspec" do
+        it "allows rspec to be used" do
+          target = mock('target')
+          target.should_receive(:foo)
+          target.foo
+        end
+      end
+      """
+    When I run "spec rspec_example_spec.rb"
+    Then the stdout should match "1 example, 0 failures" 
+    And the exit code should be 0

data/features/step_definitions/running_rspec_steps.rb

@@ -0,0 +1,35 @@
+Given %r{^a file named "([^"]+)" with:$} do |file_name, code|
+  create_file(file_name, code)
+end
+
+When %r{^I run "r?spec ([^"]+)"$} do |file_and_args|
+  spec(file_and_args)
+end
+
+When %r{^I run "ruby ([^"]+)"$} do |file_and_args|
+  ruby(file_and_args)
+end
+
+Then /^the (.*) should match (.*)$/ do |stream, string_or_regex|
+  written = case(stream)
+    when 'stdout' then last_stdout
+    when 'stderr' then last_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 last_stdout
+    when 'stderr' then last_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 last_exit_code != exit_code.to_i
+    raise "Did not exit with #{exit_code}, but with #{last_exit_code}. Standard error:\n#{last_stderr}"
+  end
+end

data/features/subject/explicit_subject.feature

@@ -0,0 +1,31 @@
+Feature: explicit subject
+
+  You can override the implicit subject using the subject() method.
+  
+  Scenario: subject in top level group
+    Given a file named "top_level_subject_spec.rb" with:
+      """
+      describe Array, "with some elements" do
+        subject { [1,2,3] }
+        it "should have the prescribed elements" do
+          subject.should == [1,2,3]
+        end
+      end
+      """
+    When I run "spec top_level_subject_spec.rb"
+    Then the stdout should match "1 example, 0 failures"
+
+  Scenario: subject in a nested group
+    Given a file named "nested_subject_spec.rb" with:
+      """
+      describe Array do
+        subject { [1,2,3] }
+        describe "with some elements" do
+          it "should have the prescribed elements" do
+            subject.should == [1,2,3]
+          end
+        end
+      end
+      """
+    When I run "spec nested_subject_spec.rb"
+    Then the stdout should match "1 example, 0 failures"

data/features/subject/implicit_subject.feature

@@ -0,0 +1,31 @@
+Feature: implicit subject
+
+  The first argument to the outermost example group block is
+  made available to each example as an implicit subject of
+  that example.
+  
+  Scenario: subject in top level group
+    Given a file named "top_level_subject_spec.rb" with:
+      """
+      describe Array, "when first created" do
+        it "should be empty" do
+          subject.should == []
+        end
+      end
+      """
+    When I run "spec top_level_subject_spec.rb"
+    Then the stdout should match "1 example, 0 failures"
+
+  Scenario: subject in a nested group
+    Given a file named "nested_subject_spec.rb" with:
+      """
+      describe Array do
+        describe "when first created" do
+          it "should be empty" do
+            subject.should == []
+          end
+        end
+      end
+      """
+    When I run "spec nested_subject_spec.rb"
+    Then the stdout should match "1 example, 0 failures"

data/features/support/env.rb

@@ -0,0 +1,82 @@
+$:.unshift File.join(File.dirname(__FILE__), "/../../lib")
+$:.unshift File.join(File.dirname(__FILE__), "/../../../expectations/lib")
+
+require 'forwardable'
+require 'tempfile'
+require 'spec/ruby_forker'
+require 'features/support/matchers/smart_match'
+
+
+class RspecWorld
+  include Rspec::Expectations
+  include Rspec::Matchers
+  include RubyForker
+
+  extend Forwardable
+  def_delegators RspecWorld, :working_dir, :spec_command
+  
+  def self.working_dir
+    @working_dir ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../tmp/cucumber-generated-files"))
+  end
+
+  def self.spec_command
+    @spec_command ||= File.expand_path(File.join(File.dirname(__FILE__), "/../../bin/rspec"))
+  end
+
+  RSPEC_LIB              = File.expand_path(File.join(working_dir, "/../../lib"))
+  RSPEC_EXPECTATIONS_LIB = File.expand_path(File.join(working_dir, "/../../../expectations/lib"))
+  RSPEC_MOCKS_LIB        = File.expand_path(File.join(working_dir, "/../../../mocks/lib"))
+  
+  def spec(args)
+    ruby("#{spec_command} #{args}")
+  end
+
+  def create_file(file_name, contents)
+    file_path = File.join(working_dir, file_name)
+    File.open(file_path, "w") { |f| f << contents }
+  end
+
+  def last_stdout
+    @stdout
+  end
+
+  def last_stderr
+    @stderr
+  end
+
+  def last_exit_code
+    @exit_code
+  end
+  
+  def rspec_libs
+    result = "-I #{RSPEC_LIB}"
+    if File.directory?(RSPEC_EXPECTATIONS_LIB)
+      result << " -I #{RSPEC_EXPECTATIONS_LIB}"
+    end
+    if File.directory?(RSPEC_MOCKS_LIB)
+      result << " -I #{RSPEC_MOCKS_LIB}"
+    end
+    result
+  end
+
+  # it seems like this, and the last_* methods, could be moved into RubyForker-- is that being used anywhere but the features?
+  def ruby(args)
+    stderr_file = Tempfile.new('rspec')
+    stderr_file.close
+    Dir.chdir(working_dir) do
+      @stdout = super("#{rspec_libs} #{args}", stderr_file.path)
+    end
+    @stderr = IO.read(stderr_file.path)
+    @exit_code = $?.to_i
+  end
+
+end
+
+Before do
+  FileUtils.rm_rf   RspecWorld.working_dir if test ?d, RspecWorld.working_dir
+  FileUtils.mkdir_p RspecWorld.working_dir
+end
+
+World do
+  RspecWorld.new
+end

data/features/support/matchers/smart_match.rb

@@ -0,0 +1,14 @@
+require 'rspec/expectations'
+
+Rspec::Matchers.define :smart_match do |expected|
+  match do |actual|
+    case expected
+    when /^\/.*\/?$/
+      actual =~ eval(expected)
+    when /^".*"$/
+      actual.index(eval(expected))
+    else
+      false
+    end
+  end
+end

data/lib/rspec/autorun.rb

@@ -0,0 +1,2 @@
+require 'rspec/core'
+Rspec::Core.configuration.autorun!

data/lib/rspec/core.rb

@@ -0,0 +1,38 @@
+require 'rspec/core/deprecation'
+require 'rspec/core/mocking/with_absolutely_nothing'
+require 'rspec/core/world'
+require 'rspec/core/configuration'
+require 'rspec/core/command_line_options'
+require 'rspec/core/runner'
+require 'rspec/core/example'
+require 'rspec/core/kernel_extensions'
+require 'rspec/core/shared_behaviour'
+require 'rspec/core/example_group_subject'
+require 'rspec/core/example_group'
+require 'rspec/core/formatters'
+require 'rspec/core/backward_compatibility'
+require 'rspec/core/version'
+
+module Rspec
+  module Core
+    
+    def self.install_directory
+      @install_directory ||= File.expand_path(File.dirname(__FILE__))
+      puts "@install_directory => #{@install_directory}"
+      @install_directory
+    end
+
+    def self.configuration
+      @configuration ||= Rspec::Core::Configuration.new
+    end
+
+    def self.configure
+      yield configuration if block_given?
+    end
+  
+    def self.world
+      @world ||= Rspec::Core::World.new
+    end
+    
+  end
+end

data/lib/rspec/core/backward_compatibility.rb

@@ -0,0 +1,9 @@
+module Rspec
+  module Core
+    class Configuration
+      def mock_with(use_me_to_mock)
+        self.mock_framework = use_me_to_mock
+      end
+    end
+  end
+end

data/lib/rspec/core/command_line_options.rb

@@ -0,0 +1,60 @@
+require 'optparse'
+# http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/classes/OptionParser.html
+
+module Rspec
+  module Core
+
+    class CommandLineOptions
+      
+      attr_reader :args, :options
+      
+      def self.parse(args)
+        cli_options = new(args)
+        cli_options.parse
+        cli_options
+      end
+
+      def initialize(args)
+        @args = args
+        @options = {}
+      end
+      
+      def files_to_run
+        options[:files_to_run]
+      end
+
+      def parse
+        possible_files = OptionParser.new do |opts|
+          opts.banner = "Usage: rspec [options] [files or directories]"
+
+          opts.on('-c', '--[no-]color', '--[no-]colour', 'Enable color in the output') do |o|
+            options[:color_enabled] = o
+          end
+          
+          opts.on('-f', '--formatter [FORMATTER]', 'Choose an optional formatter') do |o|
+            options[:formatter] = o
+          end
+
+          opts.on('-p', '--profile', 'Enable profiling of examples with output of the top 10 slowest examples') do |o|
+            options[:profile_examples] = o
+          end
+
+          opts.on_tail('-h', '--help', "You're looking at it.") do 
+            puts opts
+          end
+        end.parse!(@args)
+
+        options[:files_to_run] = possible_files
+        options
+      end
+      
+      def apply(config)
+        options.each do |key, value|
+          config.send("#{key}=", value)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/rspec/core/configuration.rb

@@ -0,0 +1,222 @@
+module Rspec
+  module Core
+    class Configuration
+      # Regex patterns to scrub backtrace with
+      attr_reader :backtrace_clean_patterns
+      
+      # All of the defined before/after blocks setup in the configuration
+      attr_reader :before_and_afters
+
+      # Allows you to control what examples are ran by filtering 
+      attr_reader :filter
+
+      attr_reader :exclusion_filter
+
+      # Modules that will be included or extended based on given filters
+      attr_reader :include_or_extend_modules
+
+      # Run all examples if the run is filtered, and no examples were found.  Normally this is what you want -
+      # when using focused examples for instance.  Defaults to true
+      attr_accessor :run_all_when_everything_filtered
+
+      # Enable verbose interal logging of the framework - defaults to false
+      attr_accessor :trace
+
+      attr_reader :options
+
+      def initialize
+        @run_all_when_everything_filtered = true
+        @before_and_afters = { :before => { :each => [], :all => [], :suite => [] }, :after => { :each => [], :all => [], :suite => [] } }
+        @include_or_extend_modules = []
+        @filter, @exclusion_filter = nil, nil
+        @options = default_options
+        @backtrace_clean_patterns = []
+      end
+      
+      def default_options
+        {
+          :color_enabled => false,
+          :mock_framework => nil,
+          :profile_examples => false,
+          :files_to_run => [],
+          :filename_pattern => '**/*_spec.rb',
+          :formatter_class => Rspec::Core::Formatters::ProgressFormatter,
+          :backtrace_clean_patterns => [/\/lib\/ruby\//, 
+                                        /bin\/rcov:/, 
+                                        /vendor\/rails/, 
+                                        /bin\/rspec/, 
+                                        /bin\/spec/,
+                                        /lib\/rspec\/core/,
+                                        /lib\/rspec\/expectations/,
+                                        /lib\/rspec\/mocks/]
+        }
+      end
+      
+      def cleaned_from_backtrace?(line)
+        options[:backtrace_clean_patterns].any? { |regex| line =~ regex }
+      end
+      
+      def mock_framework=(use_me_to_mock)
+        options[:mock_framework] = use_me_to_mock
+        
+        mock_framework_class = case use_me_to_mock.to_s
+        when /rspec/i
+          require 'rspec/core/mocking/with_rspec'
+          Rspec::Core::Mocking::WithRspec
+        when /mocha/i
+          require 'rspec/core/mocking/with_mocha'
+          Rspec::Core::Mocking::WithMocha
+        when /rr/i
+          require 'rspec/core/mocking/with_rr'
+          Rspec::Core::Mocking::WithRR
+        when /flexmock/i
+          require 'rspec/core/mocking/with_flexmock'
+          Rspec::Core::Mocking::WithFlexmock
+        else
+          require 'rspec/core/mocking/with_absolutely_nothing'
+          Rspec::Core::Mocking::WithAbsolutelyNothing
+        end 
+        
+        options[:mock_framework_class] = mock_framework_class
+        Rspec::Core::ExampleGroup.send(:include, mock_framework_class)
+      end
+      
+      def mock_framework
+        options[:mock_framework]
+      end
+
+      def filename_pattern
+        options[:filename_pattern]
+      end
+
+      def filename_pattern=(new_pattern)
+        options[:filename_pattern] = new_pattern
+      end 
+
+      def color_enabled=(on_or_off)
+        options[:color_enabled] = on_or_off
+      end
+
+      def color_enabled?
+        options[:color_enabled]
+      end
+      
+      # Enable profiling of example run - defaults to false
+      def profile_examples
+        options[:profile_examples]
+      end
+      
+      def profile_examples=(profile)
+        options[:profile_examples] = on_or_off
+      end
+     
+      def formatter_class
+        options[:formatter_class]
+      end
+     
+      def formatter=(formatter_to_use)
+        formatter_class = case formatter_to_use.to_s
+        when /doc/, 's'
+          Rspec::Core::Formatters::DocumentationFormatter
+        when 'progress' 
+          Rspec::Core::Formatters::ProgressFormatter
+        else 
+          raise ArgumentError, "Formatter '#{formatter_to_use}' unknown - maybe you meant 'documentation' or 'progress'?."
+        end
+        options[:formatter_class] = formatter_class
+      end
+        
+      def formatter
+        @formatter ||= formatter_class.new
+      end
+      
+      def files_to_run
+        options[:files_to_run]
+      end
+      
+      def files_to_run=(*files)
+        files.flatten!
+
+        result = []
+        files.each do |file|
+          if File.directory?(file)
+            filename_pattern.split(",").each do |pattern|
+              result += Dir[File.expand_path("#{file}/#{pattern.strip}")]
+            end
+          elsif File.file?(file)
+            result << file
+          else
+            raise "File or directory not found: #{file}"
+          end
+        end
+
+        options[:files_to_run] = result
+      end
+
+      # E.g. alias_example_to :crazy_slow, :speed => 'crazy_slow' defines
+      # crazy_slow as an example variant that has the crazy_slow speed option
+      def alias_example_to(new_name, extra_options={})
+        Rspec::Core::ExampleGroup.alias_example_to(new_name, extra_options)
+      end
+
+      def autorun!
+        Rspec::Core::Runner.autorun
+      end
+
+      def filter_run(options={})
+        @filter = options
+      end
+
+      def run_all_when_everything_filtered?
+        @run_all_when_everything_filtered
+      end
+
+      # Where does output go? For now $stdout
+      def output
+        $stdout
+      end
+
+      def puts(msg='')
+        output.puts(msg)    
+      end
+
+      def parse_command_line_args(args)
+        @command_line_options = Rspec::Core::CommandLineOptions.parse(args)
+      end
+
+      def include(mod, options={})
+        include_or_extend_modules << [:include, mod, options]
+      end
+
+      def extend(mod, options={})
+        include_or_extend_modules << [:extend, mod, options]
+      end
+
+      def find_modules(group)
+        include_or_extend_modules.select do |include_or_extend, mod, options|
+          options.all? do |filter_on, filter|
+            Rspec::Core.world.apply_condition(filter_on, filter, group.metadata)
+          end
+        end
+      end
+
+      def before(each_or_all=:each, options={}, &block)
+        before_and_afters[:before][each_or_all] << [options, block]
+      end
+
+      def after(each_or_all=:each, options={}, &block)
+        before_and_afters[:after][each_or_all] << [options, block]
+      end
+
+      def find_before_or_after(desired_before_or_after, desired_each_or_all, group)
+        before_and_afters[desired_before_or_after][desired_each_or_all].select do |options, block|
+          options.all? do |filter_on, filter|
+            Rspec::Core.world.apply_condition(filter_on, filter, group.metadata)
+          end
+        end.map { |options, block| block }
+      end
+
+    end
+
+  end
+end