aslakhellesoy-cucumber 0.1.99.15 → 0.1.99.17

data/lib/cucumber/formatter/ansicolor.rb

@@ -41,7 +41,7 @@ module Cucumber
     # * <tt>skipped</tt>       - defaults to <tt>cyan</tt>
     # * <tt>skipped_param</tt> - defaults to <tt>cyan,bold</tt>
     # * <tt>comment</tt>       - defaults to <tt>grey</tt>
-    # * <tt>tag</tt>           - defaults to <tt>blue</tt>
+    # * <tt>tag</tt>           - defaults to <tt>cyan</tt>
     #
     # For instance, if your shell has a black background and a green font (like the
     # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
@@ -81,7 +81,7 @@ module Cucumber
         'outline'   => 'cyan',
         'skipped'   => 'cyan',
         'comment'   => 'grey',
-        'tag'       => 'blue'
+        'tag'       => 'cyan'
       })
 
       if ENV['CUCUMBER_COLORS'] # Example: export CUCUMBER_COLORS="passed=red:failed=yellow"

data/lib/cucumber/formatter/console.rb

@@ -82,7 +82,7 @@ module Cucumber
         undefined = features.steps[:undefined]
         return if undefined.empty?
         snippets = undefined.map do |step|
-          step_name = StepMother::Undefined === step.exception ? step.exception.step_name : step.name
+          step_name = Undefined === step.exception ? step.exception.step_name : step.name
           snippet = @step_mother.snippet_text(step.actual_keyword, step_name)
           snippet
         end.compact.uniq

data/lib/cucumber/parser/feature.rb

@@ -1,6 +1,9 @@
 module Cucumber
   module Parser
     # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Also make sure you have uninstalled all cucumber gems (don't forget xxx-cucumber
+    # github gems).
+    #
     # Treetop will then generate the parser in-memory. When you're happy, just generate
     # the rb file with tt feature.tt
     module Feature
@@ -49,6 +52,7 @@ module Cucumber
         def feature_elements
           elements[7]
         end
+
       end
 
       module Feature2
@@ -150,6 +154,15 @@ module Cucumber
                     if r14
                       r16 = _nt_feature_elements
                       s0 << r16
+                      if r16
+                        r18 = _nt_comment
+                        if r18
+                          r17 = r18
+                        else
+                          r17 = SyntaxNode.new(input, index...index)
+                        end
+                        s0 << r17
+                      end
                     end
                   end
                 end
@@ -336,6 +349,9 @@ module Cucumber
           elements[0]
         end
 
+        def white
+          elements[1]
+        end
       end
 
       module Comment1
@@ -358,21 +374,7 @@ module Cucumber
           r2 = _nt_comment_line
           s1 << r2
           if r2
-            s3, i3 = [], index
-            loop do
-              r4 = _nt_eol
-              if r4
-                s3 << r4
-              else
-                break
-              end
-            end
-            if s3.empty?
-              self.index = i3
-              r3 = nil
-            else
-              r3 = SyntaxNode.new(input, i3...index, s3)
-            end
+            r3 = _nt_white
             s1 << r3
           end
           if s1.last
@@ -612,6 +614,10 @@ module Cucumber
         def steps
           elements[7]
         end
+
+        def white
+          elements[8]
+        end
       end
 
       module Scenario1
@@ -694,6 +700,10 @@ module Cucumber
                     if r8
                       r12 = _nt_steps
                       s0 << r12
+                      if r12
+                        r13 = _nt_white
+                        s0 << r13
+                      end
                     end
                   end
                 end
@@ -747,6 +757,10 @@ module Cucumber
         def examples_sections
           elements[8]
         end
+
+        def white
+          elements[9]
+        end
       end
 
       module ScenarioOutline1
@@ -807,6 +821,10 @@ module Cucumber
                       if r9
                         r10 = _nt_examples_sections
                         s0 << r10
+                        if r10
+                          r11 = _nt_white
+                          s0 << r11
+                        end
                       end
                     end
                   end
@@ -1190,12 +1208,7 @@ module Cucumber
             break
           end
         end
-        if s0.empty?
-          self.index = i0
-          r0 = nil
-        else
-          r0 = SyntaxNode.new(input, i0...index, s0)
-        end
+        r0 = SyntaxNode.new(input, i0...index, s0)
 
         node_cache[:line_to_eol][start_index] = r0
 

data/lib/cucumber/parser/feature.tt

@@ -1,6 +1,9 @@
 module Cucumber
   module Parser
     # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Also make sure you have uninstalled all cucumber gems (don't forget xxx-cucumber
+    # github gems).
+    #
     # Treetop will then generate the parser in-memory. When you're happy, just generate
     # the rb file with tt feature.tt
     grammar Feature
@@ -8,7 +11,15 @@ module Cucumber
       include Table
 
       rule feature
-        white comment white tags white header:(!(scenario_outline / scenario / background) .)* background:(background)? feature_elements {
+        white 
+        comment 
+        white 
+        tags 
+        white 
+        header:(!(scenario_outline / scenario / background) .)* 
+        background:(background)? 
+        feature_elements
+        comment? {
           def build
             if background.respond_to?(:build)
               Ast::Feature.new(comment.build, tags.build, header.text_value, feature_elements.build, background.build)
@@ -33,7 +44,7 @@ module Cucumber
       end
 
       rule comment
-        (comment_line eol+)* {
+        (comment_line white)* {
           def build
             Ast::Comment.new(text_value)
           end
@@ -66,7 +77,7 @@ module Cucumber
       end
 
       rule scenario
-        comment tags white scenario_keyword space* name:line_to_eol (eol+ / eof) steps {
+        comment tags white scenario_keyword space* name:line_to_eol (eol+ / eof) steps white {
           def build
             Ast::Scenario.new(
               comment.build, 
@@ -81,7 +92,7 @@ module Cucumber
       end
 
       rule scenario_outline
-        comment tags white scenario_outline_keyword space* name:line_to_eol white steps examples_sections {
+        comment tags white scenario_outline_keyword space* name:line_to_eol white steps examples_sections white {
           def build
             Ast::ScenarioOutline.new(
               comment.build, 
@@ -137,7 +148,7 @@ module Cucumber
       end
 
       rule line_to_eol
-        (!eol .)+
+        (!eol .)*
       end
 
       rule py_string

data/lib/cucumber/parser/table.rb

@@ -1,5 +1,11 @@
 module Cucumber
   module Parser
+    # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Also make sure you have uninstalled all cucumber gems (don't forget xxx-cucumber
+    # github gems).
+    #
+    # Treetop will then generate the parser in-memory. When you're happy, just generate
+    # the rb file with tt feature.tt
     module Table
       include Treetop::Runtime
 

data/lib/cucumber/parser/table.tt

@@ -1,5 +1,11 @@
 module Cucumber
   module Parser
+    # TIP: When you hack on the grammar, just delete feature.rb in this directory.
+    # Also make sure you have uninstalled all cucumber gems (don't forget xxx-cucumber
+    # github gems).
+    #
+    # Treetop will then generate the parser in-memory. When you're happy, just generate
+    # the rb file with tt feature.tt
     grammar Table
 
       rule table

data/lib/cucumber/parser/treetop_ext.rb

@@ -1,6 +1,14 @@
-require 'treetop'
-require 'treetop/runtime'
-require 'treetop/ruby_extensions'
+begin
+  require 'treetop'
+  require 'treetop/runtime'
+  require 'treetop/ruby_extensions'
+rescue LoadError
+  require "rubygems"
+  gem "treetop"
+  require 'treetop'
+  require 'treetop/runtime'
+  require 'treetop/ruby_extensions'
+end
 
 module Cucumber
   module Parser
@@ -32,7 +40,7 @@ module Cucumber
     class SyntaxError < StandardError
       def initialize(parser, file, line_offset)
         tf = parser.terminal_failures
-        expected = tf.size == 1 ? tf[0].expected_string.inspect : "one of #{tf.map{|f| f.expected_string}.uniq*', '}"
+        expected = tf.size == 1 ? tf[0].expected_string.inspect : "one of #{tf.map{|f| f.expected_string.inspect}.uniq*', '}"
         line = parser.failure_line + line_offset
         message = "#{file}:#{line}:#{parser.failure_column}: Parse error, expected #{expected}."
         super(message)

data/lib/cucumber/step_mother.rb

@@ -2,47 +2,48 @@ require 'cucumber/step_definition'
 require 'cucumber/core_ext/instance_exec'
 
 module Cucumber
-  # This is the main interface for registering step definitions, which is done
-  # from <tt>*_steps.rb</tt> files. This module is included right at the top-level
-  # so #register_step_definition (and more interestingly - its aliases) are
-  # available from the top-level.
-  module StepMother
-    attr_writer :snippet_generator
-
-    class Undefined < StandardError
-      attr_reader :step_name
+  class Undefined < StandardError
+    attr_reader :step_name
 
-      def initialize(step_name)
-        super %{Undefined step: "#{step_name}"}
-        @step_name = step_name
-      end
-      Cucumber::EXCEPTION_STATUS[self] = :undefined
+    def initialize(step_name)
+      super %{Undefined step: "#{step_name}"}
+      @step_name = step_name
     end
+    Cucumber::EXCEPTION_STATUS[self] = :undefined
+  end
 
-    class Pending < StandardError
-      Cucumber::EXCEPTION_STATUS[self] = :pending
-    end
+  class Pending < StandardError
+    Cucumber::EXCEPTION_STATUS[self] = :pending
+  end
 
-    # Raised when a step matches 2 or more StepDefinition
-    class Ambiguous < StandardError
-      def initialize(step_name, step_definitions)
-        message = "Ambiguous match of \"#{step_name}\":\n\n"
-        message << step_definitions.map{|sd| sd.to_backtrace_line}.join("\n")
-        message << "\n\n"
-        super(message)
-      end
+  # Raised when a step matches 2 or more StepDefinition
+  class Ambiguous < StandardError
+    def initialize(step_name, step_definitions)
+      message = "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map{|sd| sd.to_backtrace_line}.join("\n")
+      message << "\n\n"
+      super(message)
     end
+  end
 
-    # Raised when 2 or more StepDefinition have the same Regexp
-    class Redundant < StandardError
-      def initialize(step_def_1, step_def_2)
-        message = "Multiple step definitions have the same Regexp:\n\n"
-        message << step_def_1.to_backtrace_line << "\n"
-        message << step_def_2.to_backtrace_line << "\n\n"
-        super(message)
-      end
+  # Raised when 2 or more StepDefinition have the same Regexp
+  class Redundant < StandardError
+    def initialize(step_def_1, step_def_2)
+      message = "Multiple step definitions have the same Regexp:\n\n"
+      message << step_def_1.to_backtrace_line << "\n"
+      message << step_def_2.to_backtrace_line << "\n\n"
+      super(message)
     end
+  end
 
+  # This is the main interface for registering step definitions, which is done
+  # from <tt>*_steps.rb</tt> files. This module is included right at the top-level
+  # so #register_step_definition (and more interestingly - its aliases) are
+  # available from the top-level.
+  module StepMother
+    attr_writer :snippet_generator
+    attr_writer :options
+    
     # Registers a new StepDefinition. This method is aliased
     # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>.
     #
@@ -112,10 +113,22 @@ module Cucumber
         step_definition.match(step_name)
       end
       raise Undefined.new(step_name) if found.empty?
+      found = best_matches(step_name, found) if found.size > 1 && options[:guess]
       raise Ambiguous.new(step_name, found) if found.size > 1
       found[0]
     end
 
+    def best_matches(step_name, step_definitions)
+      top_group_score = step_definitions.map {|s| s.match(step_name).captures.length }.sort.last
+      top_groups = step_definitions.select {|s| s.match(step_name).captures.length == top_group_score }
+      if top_groups.size > 1
+        shortest_capture_length = top_groups.map {|s| s.match(step_name).captures.inject(0) {|sum, c| sum + c.length } }.sort.first
+        top_groups.select {|s| s.match(step_name).captures.inject(0) {|sum, c| sum + c.length } == shortest_capture_length }
+      else
+        top_groups
+      end
+    end
+    
     def step_definitions
       @step_definitions ||= []
     end
@@ -124,6 +137,12 @@ module Cucumber
       @snippet_generator.snippet_text(step_keyword, step_name)
     end
 
+    private
+    
+    def options
+      @options || {}
+    end
+
     module WorldMethods #:nodoc:
       attr_writer :__cucumber_step_mother, :__cucumber_current_step
 

data/lib/cucumber/version.rb

@@ -3,7 +3,7 @@ module Cucumber #:nodoc:
     MAJOR = 0
     MINOR = 1
     TINY  = 99
-    PATCH = 15 # Set to nil for official release
+    PATCH = 17 # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
   end

data/spec/cucumber/cli/configuration_spec.rb

@@ -0,0 +1,239 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'yaml'
+
+module Cucumber
+module Cli
+  describe Configuration do
+    
+    def given_cucumber_yml_defined_as(hash_or_string)
+      File.stub!(:exist?).and_return(true)
+      cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
+      IO.stub!(:read).with('cucumber.yml').and_return(cucumber_yml)
+    end
+    
+    before(:each) do
+      Kernel.stub!(:exit).and_return(nil)
+    end
+
+    it "should require files in support paths first" do
+      File.stub!(:directory?).and_return(true)
+      Dir.stub!(:[]).and_return(["/features/step_definitions/foo.rb","/features/support/env.rb"])
+      
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--require /features})
+
+      config.files_to_require.should == [
+        "/features/support/env.rb",
+        "/features/step_definitions/foo.rb"
+      ]
+    end
+    
+    it "should expand args from YAML file" do
+      given_cucumber_yml_defined_as({'bongo' => '--require from/yml'})
+
+      config = Configuration.new
+      config.parse!(%w{--format progress --profile bongo})
+      config.options[:formats].should == {'progress' => STDOUT}
+      config.options[:require].should == ['from/yml']
+    end
+
+    it "should expand args from YAML file's default if there are no args" do
+      given_cucumber_yml_defined_as({'default' => '--require from/yml'})
+
+      config = Configuration.new
+      config.parse!([])
+      config.options[:require].should == ['from/yml']
+    end
+
+    it "should provide a helpful error message when a specified profile does not exists in YAML file" do
+      given_cucumber_yml_defined_as({'default' => '--require from/yml', 'html_report' =>  '--format html'})
+
+      config = Configuration.new(StringIO.new, error = StringIO.new)
+      config.parse!(%w{--profile i_do_not_exist})
+
+      expected_message = <<-END_OF_MESSAGE
+Could not find profile: 'i_do_not_exist'
+
+Defined profiles in cucumber.yml:
+  * default
+  * html_report
+END_OF_MESSAGE
+
+      error.string.should == expected_message
+    end
+
+    it "should provide a helpful error message when a specified profile is not a String" do
+      given_cucumber_yml_defined_as({'foo' => [1,2,3]})
+
+      config = Configuration.new(StringIO.new, error = StringIO.new)
+      config.parse!(%w{--profile foo})
+
+      error.string.should == "Profiles must be defined as a String.  The 'foo' profile was [1, 2, 3] (Array).\n"
+    end
+
+    it "should provide a helpful error message when a specified profile exists but is nil or blank" do
+      [nil, '   '].each do |bad_input|
+        given_cucumber_yml_defined_as({'foo' => bad_input})
+
+        config = Configuration.new(StringIO.new, error = StringIO.new)
+        config.parse!(%w{--profile foo})
+
+        error.string.should match(/The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml./)
+      end
+    end
+
+    it "should provide a helpful error message when no YAML file exists and a profile is specified" do
+      File.should_receive(:exist?).with('cucumber.yml').and_return(false)
+
+      config = Configuration.new(StringIO.new, error = StringIO.new)
+      config.parse!(%w{--profile i_do_not_exist})
+
+      error.string.should match(/cucumber.yml was not found.  Please refer to cucumber's documentaion on defining profiles in cucumber.yml./)
+    end
+
+    it "should provide a helpful error message when cucumber.yml is blank or malformed" do
+        expected_error_message = /cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentaion on correct profile usage./
+
+      ['', 'sfsadfs', "--- \n- an\n- array\n", "---dddfd"].each do |bad_input|
+        given_cucumber_yml_defined_as(bad_input)
+        
+        config = Configuration.new(StringIO.new, error = StringIO.new)
+        config.parse!([])
+
+        error.string.should match(expected_error_message)
+      end
+    end
+
+    it "should procide a helpful error message when the YAML can not be parsed" do
+      expected_error_message = /cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentaion on correct profile usage./
+
+      given_cucumber_yml_defined_as("input that causes an exception in YAML loading")
+      YAML.should_receive(:load).and_raise Exception
+
+      config = Configuration.new(StringIO.new, error = StringIO.new)
+      config.parse!([])
+
+      error.string.should match(expected_error_message)
+    end
+
+    it "should accept --dry-run option" do
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--dry-run})
+      config.options[:dry_run].should be_true
+    end
+
+    it "should accept --no-source option" do
+      config = Configuration.new
+      config.parse!(%w{--no-source})
+
+      config.options[:source].should be_false
+    end
+
+    it "should accept --no-snippets option" do
+      config = Configuration.new
+      config.parse!(%w{--no-snippets})
+
+      config.options[:snippets].should be_false
+    end
+
+    it "should set snippets and source to false with --quiet option" do
+      config = Configuration.new
+      config.parse!(%w{--quiet})
+
+      config.options[:snippets].should be_nil
+      config.options[:source].should be_nil
+    end
+
+    it "should accept --verbose option" do
+      config = Configuration.new
+      config.parse!(%w{--verbose})
+
+      config.options[:verbose].should be_true
+    end
+        
+    it "should accept --out option" do
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--out jalla.txt})
+      config.options[:formats]['pretty'].should == 'jalla.txt'
+    end
+
+    it "should accept multiple --out options" do
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--format progress --out file1 --out file2})
+      config.options[:formats].should == {'progress' => 'file2'}
+    end
+
+    it "should accept multiple --format options" do
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--format pretty --format progress})
+      config.options[:formats].should have_key('pretty')
+      config.options[:formats].should have_key('progress')
+    end
+    
+    it "should associate --out to previous --format" do
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--format progress --out file1 --format profile --out file2})
+      config.options[:formats].should == {"profile"=>"file2", "progress"=>"file1"}
+    end
+    
+    it "should accept --color option" do
+      Term::ANSIColor.should_receive(:coloring=).with(true)
+      config = Configuration.new(StringIO.new)
+      config.parse!(['--color'])
+    end
+
+    it "should accept --no-color option" do
+      Term::ANSIColor.should_receive(:coloring=).with(false)
+      config = Configuration.new(StringIO.new)
+      config.parse!(['--no-color'])
+    end
+    
+    describe "--backtrace" do
+      before do
+        Exception.cucumber_full_backtrace = false
+      end
+      
+      it "should show full backtrace when --backtrace is present" do
+        config = Main.new(['--backtrace'])
+        begin
+          "x".should == "y"
+        rescue => e
+          e.backtrace[0].should_not == "#{__FILE__}:#{__LINE__ - 2}"
+        end
+      end
+
+      xit "should strip gems when --backtrace is absent" do
+        config = Main.new(['--'])
+        begin
+          "x".should == "y"
+        rescue => e
+          e.backtrace[0].should == "#{__FILE__}:#{__LINE__ - 2}"
+        end
+      end
+
+      after do
+        Exception.cucumber_full_backtrace = false
+      end
+    end
+    
+    it "should accept multiple --scenario options" do
+      config = Configuration.new
+      config.parse!(['--scenario', "User logs in", '--scenario', "User signs up"])
+      
+      config.options[:scenario_names].should include("User logs in")
+      config.options[:scenario_names].should include("User signs up")
+    end
+    
+    it "should search for all features in the specified directory" do
+      File.stub!(:directory?).and_return(true)
+      Dir.should_receive(:[]).with("feature_directory/**/*.feature").any_number_of_times.and_return(["cucumber.feature"])
+      
+      config = Configuration.new(StringIO)
+      config.parse!(%w{feature_directory/})
+      
+      config.feature_files.should == ["cucumber.feature"]
+    end
+    
+  end
+end
+end