casecumber 1.0.2.1 → 1.2.1.cb2

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -19,18 +19,25 @@ module Cucumber
 
       class MissingProc < StandardError
         def message
-          "Step definitions must always have a proc"
+          "Step definitions must always have a proc or symbol"
         end
       end
 
-      def initialize(rb_language, regexp, proc)
-        raise MissingProc if proc.nil?
+      def initialize(rb_language, regexp, proc_or_sym, options)
+        raise MissingProc if proc_or_sym.nil?
         if String === regexp
           p = Regexp.escape(regexp)
           p = p.gsub(/\\\$\w+/, '(.*)') # Replace $var with (.*)
           regexp = Regexp.new("^#{p}$") 
         end
-        @rb_language, @regexp, @proc = rb_language, regexp, proc
+        @rb_language, @regexp, @proc = rb_language, regexp, proc_or_sym
+        if @proc.kind_of? Symbol
+          @proc = lambda do |*args|
+            target = options[:on] ? instance_exec(&options[:on]) : self
+            target.send(proc_or_sym, *args)
+          end
+        end
+
         @rb_language.available_step_definition(regexp_source, file_colon_line)
       end
 
@@ -71,7 +78,12 @@ module Cucumber
       end
 
       def file_colon_line
-        @proc.file_colon_line
+        case @proc
+        when Proc
+          @proc.file_colon_line
+        when Symbol
+          ":#{@proc}"
+        end
       end
     
       def file

data/lib/cucumber/rb_support/rb_transform.rb

@@ -34,11 +34,14 @@ module Cucumber
       end
     
       def to_s
-        strip_captures(strip_anchors(@regexp.source))
+         convert_captures(strip_anchors(@regexp.source))
       end
     
     private
-
+      def convert_captures(regexp_source)
+        regexp_source.gsub(/(\()(?!\?:)/,'(?:')
+      end
+      
       def strip_captures(regexp_source)
         regexp_source.
           gsub(/(\()/, '').

data/lib/cucumber/rb_support/rb_world.rb

@@ -4,7 +4,7 @@ module Cucumber
   module RbSupport
     # All steps are run in the context of an object that extends this module.
     module RbWorld
-      include Gherkin::Formatter::AnsiEscapes
+      AnsiEscapes = Gherkin::Formatter::AnsiEscapes
 
       class << self
         def alias_adverb(adverb)
@@ -17,12 +17,16 @@ module Cucumber
         rb = @__cucumber_step_mother.load_programming_language('rb')
         rb.execute_transforms([arg]).first
       end
-    
+
       attr_writer :__cucumber_step_mother, :__natural_language
 
-      # Call a step from within a step definition. This method is aliased to
-      # the same i18n as RbDsl.
       def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
+        STDERR.puts AnsiEscapes.failed + "WARNING: Using 'Given/When/Then' in step definitions is deprecated, use 'step' to call other steps instead:" + caller[0] + AnsiEscapes.reset
+        @__cucumber_step_mother.invoke(name, multiline_argument)
+      end
+
+      # Invoke a single step.
+      def step(name, multiline_argument=nil)
         @__cucumber_step_mother.invoke(name, multiline_argument)
       end
 
@@ -42,7 +46,7 @@ module Cucumber
       end
 
       def announce(*messages)
-        STDERR.puts failed + "WARNING: #announce is deprecated. Use #puts instead:" + caller[0] + reset
+        STDERR.puts AnsiEscapes.failed + "WARNING: #announce is deprecated. Use #puts instead:" + caller[0] + AnsiEscapes.reset
         puts(*messages)
       end
 

data/lib/cucumber/rb_support/regexp_argument_matcher.rb

@@ -1,4 +1,4 @@
-require 'cucumber/step_argument'
+require 'gherkin/formatter/argument'
 
 module Cucumber
   module RbSupport
@@ -9,8 +9,8 @@ module Cucumber
           n = 0
           match.captures.map do |val|
             n += 1
-            start = match.offset(n)[0]
-            StepArgument.new(val, start)
+            offset = match.offset(n)[0]
+            Gherkin::Formatter::Argument.new(offset, val)
           end
         else
           nil

data/lib/cucumber/runtime/results.rb

@@ -54,11 +54,11 @@ module Cucumber
         if @configuration.wip?
           scenarios(:passed).any?
         else
-          scenarios(:failed).any? ||
+          scenarios(:failed).any? || steps(:failed).any? ||
           (@configuration.strict? && (steps(:undefined).any? || steps(:pending).any?))
         end
       end
     end
     
   end
-end
+end

data/lib/cucumber/runtime/support_code.rb

@@ -1,7 +1,9 @@
 require 'cucumber/constantize'
+require 'cucumber/ast/multiline_argument'
 require 'cucumber/runtime/for_programming_languages'
 
 module Cucumber
+
   class Runtime
     
     class SupportCode
@@ -18,15 +20,7 @@ module Cucumber
         end
 
         def step(step)
-          cucumber_multiline_arg = case(rubify(step.multiline_arg))
-          when Gherkin::Formatter::Model::DocString
-            step.multiline_arg.value
-          when Array
-            Ast::Table.new(step.multiline_arg.map{|row| row.cells})
-          else
-            nil
-          end
-          @support_code.invoke(step.name, cucumber_multiline_arg) 
+          @support_code.invoke(step.name, Ast::MultilineArgument.from(step.doc_string || step.rows)) 
         end
 
         def eof
@@ -58,6 +52,17 @@ module Cucumber
         parser = Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps')
         parser.parse(steps_text, file, line.to_i)
       end
+
+      def invoke(step_name, multiline_argument=nil)
+        multiline_argument = Cucumber::Ast::MultilineArgument.from(multiline_argument)
+        # It is very important to leave multiline_argument=nil as a vararg. Cuke4Duke needs it that way. 
+        begin
+          step_match(step_name).invoke(multiline_argument)
+        rescue Exception => e
+          e.nested! if Undefined === e
+          raise e
+        end
+      end
       
       # Loads and registers programming language implementation.
       # Instances are cached, so calling with the same argument
@@ -132,16 +137,6 @@ module Cucumber
         matches[0]
       end
     
-      def invoke(step_name, multiline_argument=nil)
-        # It is very important to leave multiline_argument=nil as a vararg. Cuke4Duke needs it that way. 
-        begin
-          step_match(step_name).invoke(multiline_argument)
-        rescue Exception => e
-          e.nested! if Undefined === e
-          raise e
-        end
-      end
-
     private
   
       def guess_step_matches?

data/lib/cucumber/runtime.rb

@@ -1,3 +1,4 @@
+require 'fileutils'
 require 'gherkin/rubify'
 require 'gherkin/i18n'
 require 'cucumber/configuration'
@@ -118,6 +119,43 @@ module Cucumber
       @support_code.unknown_programming_language?
     end
 
+    def write_stepdefs_json
+      if(@configuration.dotcucumber)
+        stepdefs = []
+        @support_code.step_definitions.sort{|a,b| a.to_hash['source'] <=> a.to_hash['source']}.each do |stepdef|
+          stepdef_hash = stepdef.to_hash
+          steps = []
+          features.each do |feature|
+            feature.feature_elements.each do |feature_element|
+              feature_element.raw_steps.each do |step|
+                args = stepdef.arguments_from(step.name)
+                if(args)
+                  steps << {
+                    'name' => step.name,
+                    'args' => args.map do |arg|
+                      {
+                        'offset' => arg.offset,
+                        'val' => arg.val
+                      }
+                    end
+                  }
+                end
+              end
+            end
+          end
+          stepdef_hash['file_colon_line'] = stepdef.file_colon_line
+          stepdef_hash['steps'] = steps.uniq.sort {|a,b| a['name'] <=> b['name']}
+          stepdefs << stepdef_hash
+        end
+        if !File.directory?(@configuration.dotcucumber)
+          FileUtils.mkdir_p(@configuration.dotcucumber)
+        end
+        File.open(File.join(@configuration.dotcucumber, 'stepdefs.json'), 'w') do |io|
+          io.write(JSON.pretty_generate(stepdefs))
+        end
+      end
+    end
+
   private
 
     def fire_after_configuration_hook #:nodoc
@@ -125,11 +163,11 @@ module Cucumber
     end
 
     def features
-      loader = Runtime::FeaturesLoader.new(
+      @loader ||= Runtime::FeaturesLoader.new(
         @configuration.feature_files, 
         @configuration.filters, 
         @configuration.tag_expression)
-      loader.features
+      @loader.features
     end
 
     def load_step_definitions

data/lib/cucumber/step_match.rb

@@ -20,7 +20,6 @@ module Cucumber
     end
 
     def invoke(multiline_arg)
-      multiline_arg = Ast::DocString.new(multiline_arg) if String === multiline_arg
       all_args = args
       all_args << multiline_arg.to_step_definition_arg if multiline_arg
       @step_definition.invoke(all_args)
@@ -61,7 +60,7 @@ module Cucumber
       s = string.dup
       offset = past_offset = 0
       step_arguments.each do |step_argument|
-        next if step_argument.byte_offset.nil? || step_argument.byte_offset < past_offset
+        next if step_argument.offset.nil? || step_argument.offset < past_offset
         
         replacement = if block_given?
           proc.call(step_argument.val)
@@ -71,9 +70,9 @@ module Cucumber
           format % step_argument.val
         end
 
-        s[step_argument.byte_offset + offset, step_argument.val.length] = replacement
+        s[step_argument.offset + offset, step_argument.val.length] = replacement
         offset += replacement.unpack('U*').length - step_argument.val.unpack('U*').length
-        past_offset = step_argument.byte_offset + step_argument.val.length
+        past_offset = step_argument.offset + step_argument.val.length
       end
       s
     end

data/lib/cucumber/term/ansicolor.rb

@@ -0,0 +1,118 @@
+module Cucumber
+  module Term
+    # The ANSIColor module can be used for namespacing and mixed into your own
+    # classes.
+    module ANSIColor
+      # :stopdoc:
+      ATTRIBUTES = [
+        [ :clear        ,   0 ], 
+        [ :reset        ,   0 ],     # synonym for :clear
+        [ :bold         ,   1 ], 
+        [ :dark         ,   2 ], 
+        [ :italic       ,   3 ],     # not widely implemented
+        [ :underline    ,   4 ], 
+        [ :underscore   ,   4 ],     # synonym for :underline
+        [ :blink        ,   5 ], 
+        [ :rapid_blink  ,   6 ],     # not widely implemented
+        [ :negative     ,   7 ],     # no reverse because of String#reverse
+        [ :concealed    ,   8 ], 
+        [ :strikethrough,   9 ],     # not widely implemented
+        [ :black        ,  30 ], 
+        [ :red          ,  31 ], 
+        [ :green        ,  32 ], 
+        [ :yellow       ,  33 ], 
+        [ :blue         ,  34 ], 
+        [ :magenta      ,  35 ], 
+        [ :cyan         ,  36 ], 
+        [ :white        ,  37 ], 
+        [ :on_black     ,  40 ], 
+        [ :on_red       ,  41 ], 
+        [ :on_green     ,  42 ], 
+        [ :on_yellow    ,  43 ], 
+        [ :on_blue      ,  44 ], 
+        [ :on_magenta   ,  45 ], 
+        [ :on_cyan      ,  46 ], 
+        [ :on_white     ,  47 ], 
+      ]
+
+      ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+      # :startdoc:
+
+      # Returns true, if the coloring function of this module
+      # is switched on, false otherwise.
+      def self.coloring?
+        @coloring
+      end
+
+      # Turns the coloring on or off globally, so you can easily do
+      # this for example:
+      #  Cucumber::Term::ANSIColor::coloring = STDOUT.isatty
+      def self.coloring=(val)
+        @coloring = val
+      end
+      self.coloring = true
+
+      ATTRIBUTES.each do |c, v|
+        eval %Q{
+            def #{c}(string = nil)
+              result = ''
+              result << "\e[#{v}m" if Cucumber::Term::ANSIColor.coloring?
+              if block_given?
+                result << yield
+              elsif string
+                result << string
+              elsif respond_to?(:to_str)
+                result << to_str
+              else
+                return result #only switch on
+              end
+              result << "\e[0m" if Cucumber::Term::ANSIColor.coloring?
+              result
+            end
+        }
+      end
+
+      # Regular expression that is used to scan for ANSI-sequences while
+      # uncoloring strings.
+      COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+
+
+      def self.included(klass)
+        if version_is_greater_than_18? and klass == String
+          ATTRIBUTES.delete(:clear)
+          ATTRIBUTE_NAMES.delete(:clear)
+        end
+      end
+
+      # Returns an uncolored version of the string, that is all
+      # ANSI-sequences are stripped from the string.
+      def uncolored(string = nil) # :yields:
+        if block_given?
+          yield.gsub(COLORED_REGEXP, '')
+        elsif string
+          string.gsub(COLORED_REGEXP, '')
+        elsif respond_to?(:to_str)
+          to_str.gsub(COLORED_REGEXP, '')
+        else
+          ''
+        end
+      end
+
+      module_function
+
+      # Returns an array of all Cucumber::Term::ANSIColor attributes as symbols.
+      def attributes
+        ATTRIBUTE_NAMES
+      end
+      extend self
+
+      private
+
+      def version_is_greater_than_18?
+        version = RUBY_VERSION.split('.')
+        version.map! &:to_i
+        version[0] >= 1 && version[1] > 8
+      end
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_protocol/requests.rb

@@ -1,4 +1,6 @@
 require 'cucumber/wire_support/request_handler'
+require 'gherkin/formatter/argument'
+
 module Cucumber
   module WireSupport
     module WireProtocol
@@ -25,7 +27,7 @@ module Cucumber
           def create_step_match(raw_step_match)
             step_definition = WireStepDefinition.new(@connection, raw_step_match)
             step_args = raw_step_match['args'].map do |raw_arg|
-              StepArgument.new(raw_arg['val'], raw_arg['pos'])
+              Gherkin::Formatter::Argument.new(raw_arg['pos'], raw_arg['val'])
             end
             step_match(step_definition, step_args)
           end
@@ -92,13 +94,13 @@ module Cucumber
         end
       
         module Tags
-          def clean_tags(scenario)
-            scenario.source_tag_names.map { |tag| tag.gsub(/^@/, '') }.sort
+          def clean_tag_names(scenario)
+            scenario.source_tags.map { |tag| tag.name.gsub(/^@/, '') }.sort
           end
           
           def request_params(scenario)
-            return nil unless scenario.source_tag_names.any?
-            { "tags" => clean_tags(scenario) }
+            return nil unless scenario.source_tags.any?
+            { "tags" => clean_tag_names(scenario) }
           end
         end
       

data/lib/cucumber/wire_support/wire_protocol.rb

@@ -1,4 +1,3 @@
-require 'cucumber/step_argument'
 require 'cucumber/wire_support/wire_protocol/requests'
 
 module Cucumber

data/lib/cucumber.rb

@@ -8,6 +8,7 @@ require 'cucumber/step_mother'
 require 'cucumber/cli/main'
 require 'cucumber/broadcaster'
 require 'cucumber/step_definitions'
+require 'cucumber/term/ansicolor'
 
 module Cucumber
   class << self
@@ -24,4 +25,4 @@ module Cucumber
       @log = logger
     end
   end
-end
+end

data/spec/cucumber/ast/doc_string_spec.rb

@@ -7,7 +7,7 @@ module Cucumber
       describe "replacing arguments" do
 
         before(:each) do
-          @ps = DocString.new("<book>\n<qty>\n")
+          @ps = DocString.new("<book>\n<qty>\n", '')
         end
       
         it "should return a new doc_string with arguments replaced with values" do
@@ -23,7 +23,7 @@ module Cucumber
         end
 
         it "should replaced nil with empty string" do
-          ps = DocString.new("'<book>'")
+          ps = DocString.new("'<book>'", '')
           doc_string_with_replaced_arg = ps.arguments_replaced({'<book>' => nil}) 
           
           doc_string_with_replaced_arg.to_step_definition_arg.should == "''"

data/spec/cucumber/ast/feature_factory.rb

@@ -1,5 +1,6 @@
 require 'cucumber/ast'
 require 'cucumber/step_mother'
+require 'gherkin/formatter/model'
 
 module Cucumber
   module Ast
@@ -24,7 +25,7 @@ module Cucumber
           %w{1 22 333},
           %w{4444 55555 666666}
         ])
-        doc_string = Ast::DocString.new(%{\n I like\nCucumber sandwich\n})
+        doc_string = Ast::DocString.new(%{\n I like\nCucumber sandwich\n}, '')
         
         background = Ast::Background.new(Ast::Comment.new(""), 2, "Background:", "", "",
           [
@@ -35,14 +36,14 @@ module Cucumber
         f = Ast::Feature.new(
           background,
           Ast::Comment.new("# My feature comment\n"),
-          Ast::Tags.new(6, ['one', 'two']),
+          Ast::Tags.new(6, [Gherkin::Formatter::Model::Tag.new('one', 6), Gherkin::Formatter::Model::Tag.new('two', 6)]),
           "Feature",
           "Pretty printing",
           "",
           [Ast::Scenario.new(
             background,
             Ast::Comment.new("    # My scenario comment  \n# On two lines \n"),
-            Ast::Tags.new(8, ['three', 'four']),
+            Ast::Tags.new(8, [Gherkin::Formatter::Model::Tag.new('three', 8), Gherkin::Formatter::Model::Tag.new('four', 8)]),
             9,
             "Scenario:", "A Scenario", "",
             [

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -52,10 +52,9 @@ module Cucumber
                   %w{20 6 14}
                 ]
               ],
-              Gherkin::Formatter::Model::Examples.new(nil, nil, nil, nil, nil, nil, nil)
+              Gherkin::Formatter::Model::Examples.new(nil, nil, nil, nil, nil, nil, nil, nil)
             ]
           ]
-
         )
       end
 

data/spec/cucumber/ast/step_spec.rb

@@ -48,7 +48,7 @@ module Cucumber
       end
 
       it "should replace arguments in py string arg" do
-        doc_string = DocString.new('taste_<taste> color_<color>')
+        doc_string = DocString.new('taste_<taste> color_<color>', '')
 
         step = Step.new(1, 'Given', 'a <color> cucumber', doc_string)
 

data/spec/cucumber/ast/table_spec.rb

@@ -45,40 +45,54 @@ module Cucumber
         @table.hashes.first[:one].should == '4444'
       end
 
-      it "should allow mapping columns" do
-        @table.map_column!('one') { |v| v.to_i }
-        @table.hashes.first['one'].should == 4444
+      it "should return the row values in order" do
+        @table.rows.first.should == %w{4444 55555 666666}
       end
 
-      it "should allow mapping columns and take a symbol as the column name" do
-        @table.map_column!(:one) { |v| v.to_i }
-        @table.hashes.first['one'].should == 4444
-      end
+      describe '#map_column!' do
+        it "should allow mapping columns" do
+          @table.map_column!('one') { |v| v.to_i }
+          @table.hashes.first['one'].should == 4444
+        end
 
-      it "should allow mapping columns and modify the rows as well" do
-        @table.map_column!(:one) { |v| v.to_i }
-        @table.rows.first.should include(4444)
-        @table.rows.first.should_not include('4444')
-      end
+        it "applies the block once to each value" do
+          headers = ['header']
+          rows = ['value']
+          table = Table.new [headers, rows]
+          count = 0
+          table.map_column!('header') { |value| count +=1 }
+          table.rows
+          count.should eq rows.size
+        end
 
-      it "should return the row values in order" do
-        @table.rows.first.should == %w{4444 55555 666666}
-      end
+        it "should allow mapping columns and take a symbol as the column name" do
+          @table.map_column!(:one) { |v| v.to_i }
+          @table.hashes.first['one'].should == 4444
+        end
 
-      it "should pass silently if a mapped column does not exist in non-strict mode" do
-        lambda {
-          @table.map_column!('two', false) { |v| v.to_i }
-        }.should_not raise_error
-      end
+        it "should allow mapping columns and modify the rows as well" do
+          @table.map_column!(:one) { |v| v.to_i }
+          @table.rows.first.should include(4444)
+          @table.rows.first.should_not include('4444')
+        end
 
-      it "should fail if a mapped column does not exist in strict mode" do
-        lambda {
-          @table.map_column!('two', true) { |v| v.to_i }
-        }.should raise_error('The column named "two" does not exist')
-      end
+        it "should pass silently if a mapped column does not exist in non-strict mode" do
+          lambda {
+            @table.map_column!('two', false) { |v| v.to_i }
+            @table.hashes
+          }.should_not raise_error
+        end
+
+        it "should fail if a mapped column does not exist in strict mode" do
+          lambda {
+            @table.map_column!('two', true) { |v| v.to_i }
+            @table.hashes
+          }.should raise_error('The column named "two" does not exist')
+        end
 
-      it "should return the table" do
-        (@table.map_column!(:one) { |v| v.to_i }).should == @table
+        it "should return the table" do
+          (@table.map_column!(:one) { |v| v.to_i }).should == @table
+        end
       end
 
       describe "#match" do
@@ -132,6 +146,16 @@ module Cucumber
             faulty_table.rows_hash
           }.should raise_error('The table must have exactly 2 columns')
         end
+
+        it "should support header and column mapping" do
+          table = Table.new([
+            %w{one 1111},
+            %w{two 22222}
+          ])
+          table.map_headers!({ 'two' => 'Two' }) { |header| header.upcase }
+          table.map_column!('two', false) { |val| val.to_i }
+          table.rows_hash.should == { 'ONE' => '1111', 'Two' => 22222 }
+        end
       end
 
       describe '#map_headers' do
@@ -378,6 +402,7 @@ module Cucumber
           ])
           lambda do
             t1.map_headers!(/uk/ => 'u')
+            t1.hashes
           end.should raise_error(%{2 headers matched /uk/: ["Cuke", "Duke"]})
         end
         
@@ -449,6 +474,15 @@ module Cucumber
             lambda { @t.dup.diff!(t) }.should_not raise_error
             lambda { @t.dup.diff!(t, :surplus_col => true) }.should raise_error
           end
+
+          it "should not raise on misplaced columns" do
+            t = table(%{
+              | b | a |
+              | d | c |
+            }, __FILE__, __LINE__)
+            lambda { @t.dup.diff!(t) }.should_not raise_error
+            lambda { @t.dup.diff!(t, :misplaced_col => true) }.should raise_error
+          end
         end
 
         def table(text, file, offset)