cucumber 0.8.5 → 0.8.6

data/fixtures/self_test/features/background/background_with_name.feature

@@ -1,7 +0,0 @@
-Feature: background with name
-  
-  Background: I'm a background and I'm ok
-    Given '10' cukes
-
-  Scenario: example
-    Then I should have '10' cukes

data/fixtures/self_test/features/background/failing_background.feature

@@ -1,12 +0,0 @@
-@after_file
-Feature: Failing background sample
-  
-  Background:
-    Given failing without a table
-    And '10' cukes
-    
-  Scenario: failing background
-    Then I should have '10' cukes
-    
-  Scenario: another failing background
-    Then I should have '10' cukes

data/fixtures/self_test/features/background/failing_background_after_success.feature

@@ -1,11 +0,0 @@
-Feature: Failing background after previously successful background sample
-
-  Background:
-    Given passing without a table
-    And '10' global cukes
-
-  Scenario: passing background
-    Then I should have '10' global cukes
-    
-  Scenario: failing background
-    Then I should have '10' global cukes

data/fixtures/self_test/features/background/multiline_args_background.feature

@@ -1,32 +0,0 @@
-Feature: Passing background with multiline args
-
-  Background:
-    Given table
-      |a|b|
-      |c|d|
-    And multiline string
-    """
-      I'm a cucumber and I'm okay. 
-      I sleep all night and I test all day
-    """
-
-  Scenario: passing background
-    Then the table should be
-      |a|b|
-      |c|d|
-    Then the multiline string should be
-    """
-      I'm a cucumber and I'm okay. 
-      I sleep all night and I test all day
-    """
-
-  Scenario: another passing background
-    Then the table should be
-      |a|b|
-      |c|d|
-    Then the multiline string should be
-    """
-      I'm a cucumber and I'm okay. 
-      I sleep all night and I test all day
-    """
-    

data/fixtures/self_test/features/background/passing_background.feature

@@ -1,10 +0,0 @@
-Feature: Passing background sample
-
-  Background:
-    Given '10' cukes
-
-  Scenario: passing background
-    Then I should have '10' cukes    
-
-  Scenario: another passing background
-    Then I should have '10' cukes

data/fixtures/self_test/features/background/pending_background.feature

@@ -1,10 +0,0 @@
-Feature: Pending background sample
-
-  Background:
-    Given pending
-
-  Scenario: pending background
-    Then I should have '10' cukes
-    
-  Scenario: another pending background
-    Then I should have '10' cukes

data/fixtures/self_test/features/background/scenario_outline_failing_background.feature

@@ -1,16 +0,0 @@
-Feature: Failing background with scenario outlines sample
-
-  Background:
-    Given failing without a table
-
-  Scenario Outline: failing background
-    Then I should have '<count>' cukes
-    Examples:
-      |count|
-      | 10  |
-
-  Scenario Outline: another failing background
-    Then I should have '<count>' cukes
-    Examples:
-      |count|
-      | 10  |

data/fixtures/self_test/features/background/scenario_outline_passing_background.feature

@@ -1,16 +0,0 @@
-Feature: Passing background with scenario outlines sample
-
-  Background:
-    Given '10' cukes
-
-  Scenario Outline: passing background
-    Then I should have '<count>' cukes
-    Examples:
-      |count|
-      | 10  |
-
-  Scenario Outline: another passing background
-    Then I should have '<count>' cukes
-    Examples:
-      |count|
-      | 10  |

data/gem_tasks/features.rake

@@ -1,14 +0,0 @@
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'cucumber/rake/task'
-require 'cucumber/platform'
-
-Cucumber::Rake::Task.new do |t|
-  if(Cucumber::JRUBY)
-    t.profile = Cucumber::WINDOWS ? 'jruby_win' : 'jruby'
-  elsif(Cucumber::WINDOWS_MRI)
-    t.profile = 'windows_mri'
-  elsif(Cucumber::RUBY_1_9)
-    t.profile = 'ruby_1_9'
-  end
-  t.rcov = ENV['RCOV']
-end

data/gem_tasks/sdoc.rake

@@ -1,12 +0,0 @@
-begin
-  require 'rake/rdoctask'
-  require 'sdoc' # and use your RDoc task the same way you used it before
-
-  Rake::RDocTask.new(:sdoc) do |rdoc|
-    rdoc.rdoc_dir = 'doc/sdoc'
-    rdoc.title = "Cucumber"
-    rdoc.options += %w{--fmt shtml -N --webcvs=http://github.com/aslakhellesoy/cucumber/blob/v0.3.96/%s --title "Cucumber API" --threads 4 --main README --exclude cucumber/parser lib}
-    rdoc.template = 'direct' # lighter template used on railsapi.com
-  end
-rescue LoadError => ignore
-end

data/lib/cucumber/ast/py_string.rb

@@ -1,80 +0,0 @@
-module Cucumber
-  module Ast
-    # Represents an inline argument in a step. Example:
-    #
-    #   Given the message
-    #     """
-    #     I like
-    #     Cucumber sandwich
-    #     """
-    #
-    # The text between the pair of <tt>"""</tt> is stored inside a PyString,
-    # which is yielded to the StepDefinition block as the last argument.
-    #
-    # The StepDefinition can then access the String via the #to_s method. In the
-    # example above, that would return: <tt>"I like\nCucumber sandwich"</tt>
-    #
-    # Note how the indentation from the source is stripped away.
-    #
-    class PyString #:nodoc:
-      class Builder
-        attr_reader :string
-
-        def initialize
-          @string = ''
-        end
-
-        def py_string(string, line_number)
-          @string = string
-        end
-
-        def eof
-        end
-      end
-
-      attr_accessor :file
-
-      def self.default_arg_name
-        "string"
-      end
-
-      def self.parse(text)
-        builder = Builder.new
-        lexer = Gherkin::I18nLexer.new(builder)
-        lexer.scan(text)
-        new(builder.string)
-      end
-
-      def initialize(string)
-        @string = string
-      end
-
-      def to_step_definition_arg
-        @string
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        visitor.visit_py_string(@string)
-      end
-      
-      def arguments_replaced(arguments) #:nodoc:
-        string = @string
-        arguments.each do |name, value|
-          value ||= ''
-          string = string.gsub(name, value)
-        end
-        PyString.new(string)
-      end
-
-      def has_text?(text)
-        @string.index(text)
-      end
-
-      # For testing only
-      def to_sexp #:nodoc:
-        [:py_string, to_step_definition_arg]
-      end
-    end
-  end
-end

data/lib/cucumber/formatter/color_io.rb

@@ -1,23 +0,0 @@
-require 'forwardable'
-
-module Cucumber
-  module Formatter
-    # Adapter to make #puts/#print/#flush work with win32console
-    class ColorIO #:nodoc:
-      extend Forwardable
-      def_delegators :@kernel, :puts, :print # win32console colours only work when sent to Kernel
-      def_delegators :@stdout, :flush, :tty?, :write, :close
-
-      def initialize(kernel, stdout)
-        @kernel = kernel
-        @stdout = stdout
-      end
-
-      # Ensure using << still gets colours in win32console
-      def <<(output)
-        print(output)
-        self
-      end
-    end
-  end
-end

data/lib/cucumber/formatter/tag_cloud.rb

@@ -1,35 +0,0 @@
-require 'cucumber/formatter/io'
-require 'cucumber/formatter/pretty'
-
-module Cucumber
-  module Formatter
-    # The formatter used for <tt>--format tag_cloud</tt>
-    # Custom formatter that prints a tag cloud as a table.
-    class TagCloud
-      include Io
-
-      def initialize(step_mother, path_or_io, options)
-        @io = ensure_io(path_or_io, "tag_cloud")
-        @options = options
-        @counts = Hash.new{|h,k| h[k] = 0}
-      end
-
-      def after_features(features)
-        print_summary(features)
-      end
-
-      def tag_name(tag_name)
-        @counts[tag_name] += 1
-      end
-      
-      private
-  
-      def print_summary(features)
-        matrix = @counts.to_a.sort{|paira, pairb| paira[0] <=> pairb[0]}.transpose
-        table = Cucumber::Ast::Table.new(matrix)
-        formatter = Cucumber::Formatter::Pretty.new(@step_mother, @io, {})
-        Cucumber::Ast::TreeWalker.new(@step_mother, [formatter], {}).visit_multiline_arg(table)
-      end
-    end
-  end
-end

data/spec/cucumber/ast/py_string_spec.rb

@@ -1,40 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-require 'cucumber/ast/py_string'
-
-module Cucumber
-  module Ast
-    describe PyString do
-      describe "replacing arguments" do
-
-        before(:each) do
-          @ps = PyString.new("<book>\n<qty>\n")
-        end
-      
-        it "should return a new py_string with arguments replaced with values" do
-          py_string_with_replaced_arg = @ps.arguments_replaced({'<book>' => 'Life is elsewhere', '<qty>' => '5'})
-                
-          py_string_with_replaced_arg.to_step_definition_arg.should == "Life is elsewhere\n5\n"
-        end
-        
-        it "should not change the original py_string" do
-          py_string_with_replaced_arg = @ps.arguments_replaced({'<book>' => 'Life is elsewhere'})
-          
-          @ps.to_s.should_not include("Life is elsewhere")
-        end
-
-        it "should replaced nil with empty string" do
-          ps = PyString.new("'<book>'")
-          py_string_with_replaced_arg = ps.arguments_replaced({'<book>' => nil}) 
-          
-          py_string_with_replaced_arg.to_step_definition_arg.should == "''"
-        end
-
-        it "should recognise when just a subset of a cell is delimited" do
-          @ps.should have_text('<qty>')
-        end
-
-      end
-      
-    end
-  end
-end

data/spec/cucumber/formatter/color_io_spec.rb

@@ -1,29 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
-require 'cucumber/formatter/color_io'
-
-module Cucumber
-  module Formatter
-    describe ColorIO do
-      describe "<<" do
-        it "should convert to a print using kernel" do
-          kernel = mock('Kernel')
-          color_io = ColorIO.new(kernel, nil)
-          
-          kernel.should_receive(:print).with("monkeys")
-          
-          color_io << "monkeys"
-        end
-        
-        it "should allow chained <<" do
-          kernel = mock('Kernel')
-          color_io = ColorIO.new(kernel, nil)
-
-          kernel.should_receive(:print).with("monkeys")
-          kernel.should_receive(:print).with(" are tasty")
-          
-          color_io << "monkeys" <<  " are tasty"
-        end
-      end
-    end
-  end
-end

data/spec/cucumber/step_mother_spec.rb

@@ -1,302 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-require 'cucumber'
-require 'cucumber/rb_support/rb_language'
-
-module Cucumber
-  describe StepMother do
-    before do
-      @dsl = Object.new
-      @dsl.extend(RbSupport::RbDsl)
-
-      @step_mother = StepMother.new
-
-      @rb = @step_mother.load_programming_language('rb')
-
-      @visitor = mock('Visitor')
-    end
-
-    it "should format step names" do
-      @dsl.Given(/it (.*) in (.*)/) do |what, month|
-      end
-      @dsl.Given(/nope something else/) do |what, month|
-      end
-      
-      format = @step_mother.step_match("it snows in april").format_args("[%s]")
-      format.should == "it [snows] in [april]"
-    end
-
-    it "should raise Ambiguous error with guess hint when multiple step definitions match" do
-      @dsl.Given(/Three (.*) mice/) {|disability|}
-      @dsl.Given(/Three blind (.*)/) {|animal|}
-
-      lambda do
-        @step_mother.step_match("Three blind mice")
-      end.should raise_error(Ambiguous, %{Ambiguous match of "Three blind mice":
-
-spec/cucumber/step_mother_spec.rb:30:in `/Three (.*) mice/'
-spec/cucumber/step_mother_spec.rb:31:in `/Three blind (.*)/'
-
-You can run again with --guess to make Cucumber be more smart about it
-})
-    end
-
-    it "should not show --guess hint when --guess is used" do
-      @step_mother.options = {:guess => true}
-
-      @dsl.Given(/Three (.*) mice/) {|disability|}
-      @dsl.Given(/Three cute (.*)/) {|animal|}
-      
-      lambda do
-        @step_mother.step_match("Three cute mice")
-      end.should raise_error(Ambiguous, %{Ambiguous match of "Three cute mice":
-
-spec/cucumber/step_mother_spec.rb:47:in `/Three (.*) mice/'
-spec/cucumber/step_mother_spec.rb:48:in `/Three cute (.*)/'
-
-})
-    end
-
-    it "should not raise Ambiguous error when multiple step definitions match, but --guess is enabled" do
-      @step_mother.options = {:guess => true}
-      @dsl.Given(/Three (.*) mice/) {|disability|}
-      @dsl.Given(/Three (.*)/) {|animal|}
-      
-      lambda do
-        @step_mother.step_match("Three blind mice")
-      end.should_not raise_error
-    end
-    
-    it "should not raise NoMethodError when guessing from multiple step definitions with nil fields" do
-      @step_mother.options = {:guess => true}
-      @dsl.Given(/Three (.*) mice( cannot find food)?/) {|disability, is_disastrous|}
-      @dsl.Given(/Three (.*)?/) {|animal|}
-      
-      lambda do
-        @step_mother.step_match("Three blind mice")
-      end.should_not raise_error
-    end
-    
-    it "should pick right step definition when --guess is enabled and equal number of capture groups" do
-      @step_mother.options = {:guess => true}
-      right = @dsl.Given(/Three (.*) mice/) {|disability|}
-      wrong = @dsl.Given(/Three (.*)/) {|animal|}
-      
-      @step_mother.step_match("Three blind mice").step_definition.should == right
-    end
-    
-    it "should pick right step definition when --guess is enabled and unequal number of capture groups" do
-      @step_mother.options = {:guess => true}
-      right = @dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
-      wrong = @dsl.Given(/Three (.*)/) {|animal|}
-      
-      @step_mother.step_match("Three blind mice ran far").step_definition.should == right
-    end
-
-    it "should pick most specific step definition when --guess is enabled and unequal number of capture groups" do
-      @step_mother.options = {:guess => true}
-      general       = @dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
-      specific      = @dsl.Given(/Three blind mice ran far/) do; end
-      more_specific = @dsl.Given(/^Three blind mice ran far$/) do; end
-      
-      @step_mother.step_match("Three blind mice ran far").step_definition.should == more_specific
-    end
-    
-    it "should raise Undefined error when no step definitions match" do
-      lambda do
-        @step_mother.step_match("Three blind mice")
-      end.should raise_error(Undefined)
-    end
-
-    # http://railsforum.com/viewtopic.php?pid=93881
-    it "should not raise Redundant unless it's really redundant" do
-      @dsl.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
-      @dsl.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
-    end
-
-    it "should raise an error if the world is nil" do
-      @dsl.World {}
-
-      begin
-        @step_mother.before_and_after(nil) do; end
-        raise "Should fail"
-      rescue RbSupport::NilWorld => e
-        e.message.should == "World procs should never return nil"
-        e.backtrace.should == ["spec/cucumber/step_mother_spec.rb:118:in `World'"]
-      end
-    end
-
-    module ModuleOne
-    end
-
-    module ModuleTwo
-    end
-
-    class ClassOne
-    end
-
-    it "should implicitly extend world with modules" do
-      @dsl.World(ModuleOne, ModuleTwo)
-      @step_mother.before(mock('scenario').as_null_object)
-      class << @rb.current_world
-        included_modules.inspect.should =~ /ModuleOne/ # Workaround for RSpec/Ruby 1.9 issue with namespaces
-        included_modules.inspect.should =~ /ModuleTwo/
-      end
-      @rb.current_world.class.should == Object
-    end
-
-    it "should raise error when we try to register more than one World proc" do
-      @dsl.World { Hash.new }
-      lambda do
-        @dsl.World { Array.new }
-      end.should raise_error(RbSupport::MultipleWorld, %{You can only pass a proc to #World once, but it's happening
-in 2 places:
-
-spec/cucumber/step_mother_spec.rb:149:in `World'
-spec/cucumber/step_mother_spec.rb:151:in `World'
-
-Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc
-or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.
-
-})
-    end
-
-    it "should find before hooks" do
-      fish = @dsl.Before('@fish'){}
-      meat = @dsl.Before('@meat'){}
-            
-      scenario = mock('Scenario')
-      scenario.should_receive(:accept_hook?).with(fish).and_return(true)
-      scenario.should_receive(:accept_hook?).with(meat).and_return(false)
-      
-      @rb.hooks_for(:before, scenario).should == [fish]
-    end
-
-    it "should find around hooks" do
-      a = @dsl.Around do |scenario, block|
-      end
-
-      b = @dsl.Around('@tag') do |scenario, block|
-      end
-
-      scenario = mock('Scenario')
-      scenario.should_receive(:accept_hook?).with(a).and_return(true)
-      scenario.should_receive(:accept_hook?).with(b).and_return(false)
-
-      @rb.hooks_for(:around, scenario).should == [a]
-    end
-  end
-
-  describe StepMother, "step argument transformations" do
-    before do
-      @dsl = Object.new
-      @dsl.extend(RbSupport::RbDsl)
-
-      @step_mother = StepMother.new
-
-      @rb = @step_mother.load_programming_language('rb')
-    end
-
-    describe "without capture groups" do
-      it "complains when registering with a with no transform block" do
-        lambda do
-          @dsl.Transform('^abc$')
-        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-      end
-      
-      it "complains when registering with a zero-arg transform block" do
-        lambda do
-          @dsl.Transform('^abc$') {42}
-        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-      end
-
-      it "complains when registering with a splat-arg transform block" do
-        lambda do
-          @dsl.Transform('^abc$') {|*splat| 42 }
-        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-      end
-
-      it "complains when transforming with an arity mismatch" do
-        lambda do
-          @dsl.Transform('^abc$') {|one, two| 42 }
-          @rb.execute_transforms(['abc'])
-        end.should raise_error(Cucumber::ArityMismatchError)
-      end
-
-      it "allows registering a regexp pattern that yields the step_arg matched" do
-        @dsl.Transform(/^ab*c$/) {|arg| 42}
-        @rb.execute_transforms(['ab']).should == ['ab']
-        @rb.execute_transforms(['ac']).should == [42]
-        @rb.execute_transforms(['abc']).should == [42]
-        @rb.execute_transforms(['abbc']).should == [42]
-      end
-    end
-
-    describe "with capture groups" do
-      it "complains when registering with a with no transform block" do
-        lambda do
-          @dsl.Transform('^a(.)c$')
-        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-      end
-      
-      it "complains when registering with a zero-arg transform block" do
-        lambda do
-          @dsl.Transform('^a(.)c$') { 42 }
-        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-      end
-
-      it "complains when registering with a splat-arg transform block" do
-        lambda do
-          @dsl.Transform('^a(.)c$') {|*splat| 42 }
-        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
-      end
-
-      it "complains when transforming with an arity mismatch" do
-        lambda do
-          @dsl.Transform('^a(.)c$') {|one, two| 42 }
-          @rb.execute_transforms(['abc'])
-        end.should raise_error(Cucumber::ArityMismatchError)
-      end
-      
-      it "allows registering a regexp pattern that yields capture groups" do
-        @dsl.Transform(/^shape: (.+), color: (.+)$/) do |shape, color|
-          {shape.to_sym => color.to_sym}
-        end
-        @rb.execute_transforms(['shape: circle, color: blue']).should == [{:circle => :blue}]
-        @rb.execute_transforms(['shape: square, color: red']).should == [{:square => :red}]
-        @rb.execute_transforms(['not shape: square, not color: red']).should == ['not shape: square, not color: red']
-      end
-    end
-    
-    it "allows registering a string pattern" do
-      @dsl.Transform('^ab*c$') {|arg| 42}
-      @rb.execute_transforms(['ab']).should == ['ab']
-      @rb.execute_transforms(['ac']).should == [42]
-      @rb.execute_transforms(['abc']).should == [42]
-      @rb.execute_transforms(['abbc']).should == [42]
-    end
-
-    it "gives match priority to transforms defined last" do
-      @dsl.Transform(/^transform_me$/) {|arg| :foo }
-      @dsl.Transform(/^transform_me$/) {|arg| :bar }
-      @dsl.Transform(/^transform_me$/) {|arg| :baz }
-      @rb.execute_transforms(['transform_me']).should == [:baz]
-    end
-    
-    it "allows registering a transform which returns nil" do
-      @dsl.Transform('^ac$') {|arg| nil}
-      @rb.execute_transforms(['ab']).should == ['ab']
-      @rb.execute_transforms(['ac']).should == [nil]
-    end
-  end
-
-end
-
-module ModuleOne
-end
-
-module ModuleTwo
-end
-
-class ClassOne
-end