cucumber 1.2.5 → 1.3.0

data/lib/cucumber/platform.rb

@@ -4,7 +4,7 @@ require 'rbconfig'
 
 module Cucumber
 unless defined?(Cucumber::VERSION)
-  VERSION       = '1.2.5'
+  VERSION       = '1.3.0'
   BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
   LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
   JRUBY         = defined?(JRUBY_VERSION)

data/lib/cucumber/py_support/py_language.rb

@@ -24,7 +24,7 @@ module Cucumber
       def alias_adverbs(adverbs)
       end
 
-      def snippet_text(code_keyword, step_name, multiline_arg_class)
+      def snippet_text(code_keyword, step_name, multiline_arg_class, snippet_type)
         "python snippet: #{code_keyword}, #{step_name}"
       end
 

data/lib/cucumber/rake/task.rb

@@ -101,7 +101,11 @@ module Cucumber
         end
 
         def run
-          sh(cmd.join(" "))
+          sh cmd.join(" ") do |ok, res|
+            if !ok
+              exit res.exitstatus
+            end
+          end
         end
       end
 

data/lib/cucumber/rb_support/rb_language.rb

@@ -4,6 +4,7 @@ require 'cucumber/rb_support/rb_world'
 require 'cucumber/rb_support/rb_step_definition'
 require 'cucumber/rb_support/rb_hook'
 require 'cucumber/rb_support/rb_transform'
+require 'cucumber/rb_support/snippet'
 
 begin
   require 'rspec/expectations'
@@ -83,25 +84,9 @@ module Cucumber
         end.compact
       end
 
-      ARGUMENT_PATTERNS = ['"(.*?)"', '(\d+)']
-
-      def snippet_text(code_keyword, step_name, multiline_arg_class)
-        snippet_pattern = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
-        arg_count = 0
-        ARGUMENT_PATTERNS.each do |pattern|
-          snippet_pattern = snippet_pattern.gsub(Regexp.new(pattern), pattern)
-          arg_count += snippet_pattern.scan(pattern).length
-        end
-
-        block_args = (0...arg_count).map {|n| "arg#{n+1}"}
-        block_args << multiline_arg_class.default_arg_name unless multiline_arg_class.nil?
-        block_arg_string = block_args.empty? ? "" : " |#{block_args.join(", ")}|"
-        multiline_class_comment = ""
-        if(multiline_arg_class == Ast::Table)
-          multiline_class_comment = "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  "
-        end
-
-        "#{code_keyword}(/^#{snippet_pattern}$/) do#{block_arg_string}\n  #{multiline_class_comment}pending # express the regexp above with the code you wish you had\nend"
+      def snippet_text(code_keyword, step_name, multiline_arg_class, snippet_type = :regexp)
+        snippet_class = typed_snippet_class(snippet_type)
+        snippet_class.new(code_keyword, step_name, multiline_arg_class).to_s
       end
 
       def begin_rb_scenario(scenario)
@@ -184,6 +169,22 @@ module Cucumber
           o
         end
       end
+
+      SNIPPET_TYPES = {
+        :regexp => Snippet::Regexp,
+        :classic => Snippet::Classic,
+        :percent => Snippet::Percent
+      }
+
+      def typed_snippet_class(type)
+        SNIPPET_TYPES.fetch(type || :regexp)
+      end
+
+      def self.cli_snippet_type_options
+        SNIPPET_TYPES.keys.sort_by(&:to_s).map do |type|
+          SNIPPET_TYPES[type].cli_option_string(type)
+        end
+      end
     end
   end
 end

data/lib/cucumber/rb_support/rb_world.rb

@@ -2,11 +2,17 @@ require 'gherkin/formatter/ansi_escapes'
 
 module Cucumber
   module RbSupport
-    # All steps are run in the context of an object that extends this module.
+    # Defines the basic DSL methods availlable in all Cucumber step definitions.
+    #
+    # You can, and probably should, extend this DSL with your own methods that
+    # make sense in your domain. For more on that, see {Cucumber::RbSupport::RbDsl#World}
     module RbWorld
+
+      # @private
       AnsiEscapes = Gherkin::Formatter::AnsiEscapes
 
       class << self
+        # @private
         def alias_adverb(adverb)
           alias_method adverb, :__cucumber_invoke
         end
@@ -18,49 +24,95 @@ module Cucumber
         rb.execute_transforms([arg]).first
       end
 
+      # @private
       attr_writer :__cucumber_runtime, :__natural_language
 
+      # @private
       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_runtime.invoke(name, multiline_argument)
       end
 
-      # Invoke a single step.
+      # Run a single Gherkin step
+      # @example Call another step
+      #   step "I am logged in"
+      # @example Call a step with quotes in the name
+      #   step %{the user "Dave" is logged in}
+      # @example Passing a table
+      #   step "the following users exist:", table(%{
+      #     | name  | email           |
+      #     | Matt  | matt@matt.com   |
+      #     | Aslak | aslak@aslak.com |
+      #   })
+      # @example Passing a multiline string
+      #   step "the email should contain:", "Dear sir,\nYou've won a prize!\n"
+      # @param [String] name The name of the step
+      # @param [String,Cucumber::Ast::DocString,Cucumber::Ast::Table] multiline_argument
       def step(name, multiline_argument=nil)
         @__cucumber_runtime.invoke(name, multiline_argument)
       end
 
-      # See StepMother#invoke_steps
+      # Run a snippet of Gherkin
+      # @example
+      #   steps %{
+      #     Given the user "Susan" exists
+      #     And I am logged in as "Susan"
+      #   }
+      # @param [String] steps_text The Gherkin snippet to run
       def steps(steps_text)
         @__cucumber_runtime.invoke_steps(steps_text, @__natural_language, caller[0])
       end
 
-      # See StepMother#table
+      # Parse Gherkin into a {Cucumber::Ast::Table} object.
+      #
+      # Useful in conjunction with the #step method.
+      # @example Create a table
+      #   users = table(%{
+      #     | name  | email           |
+      #     | Matt  | matt@matt.com   |
+      #     | Aslak | aslak@aslak.com |
+      #   })
+      # @param [String] text_or_table The Gherkin string that represents the table
       def table(text_or_table, file=nil, line_offset=0)
         @__cucumber_runtime.table(text_or_table, file, line_offset)
       end
 
-      # See StepMother#doc_string
+      # Create an {Cucumber::Ast::DocString} object
+      #
+      # Useful in conjunction with the #step method, when
+      # want to specify a content type.
+      # @example Create a multiline string
+      #   code = multiline_string(%{
+      #     puts "this is ruby code"
+      #   %}, 'ruby')
       def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
+        # TODO: rename this method to multiline_string
         @__cucumber_runtime.doc_string(string_without_triple_quotes, content_type, line_offset)
       end
 
+      # @deprecated Use {#puts} instead.
       def announce(*messages)
         STDERR.puts AnsiEscapes.failed + "WARNING: #announce is deprecated. Use #puts instead:" + caller[0] + AnsiEscapes.reset
         puts(*messages)
       end
 
-      # See StepMother#puts
+      # Print a message to the output.
+      #
+      # @note Cucumber might surprise you with the behaviour of this method. Instead
+      #   of sending the output directly to STDOUT, Cucumber will intercept and cache
+      #   the message until the current step has finished, and then display it.
+      #   
+      #   If you'd prefer to see the message immediately, call {Kernel#puts} instead.
       def puts(*messages)
         @__cucumber_runtime.puts(*messages)
       end
 
-      # See StepMother#ask
+      # Pause the tests and ask the operator for input
       def ask(question, timeout_seconds=60)
         @__cucumber_runtime.ask(question, timeout_seconds)
       end
 
-      # See StepMother#embed
+      # Embed an image in the output
       def embed(file, mime_type, label='Screenshot')
         @__cucumber_runtime.embed(file, mime_type, label)
       end
@@ -79,19 +131,8 @@ module Cucumber
         end
       end
 
-      # The default implementation of Object#inspect recursively
-      # traverses all instance variables and invokes inspect.
-      # This can be time consuming if the object graph is large.
-      #
-      # This can cause unnecessary delays when certain exceptions
-      # occur. For example, MRI internally invokes #inspect on an
-      # object that raises a NoMethodError. (JRuby does not do this).
-      #
-      # A World object can have many references created by the user
-      # or frameworks (Rails), so to avoid long waiting times on
-      # such errors in World we define it to just return a simple String.
-      #
-      def inspect #:nodoc:
+      # Prints the list of modules that are included in the World
+      def inspect
         modules = [self.class]
         (class << self; self; end).instance_eval do
           modules += included_modules
@@ -99,6 +140,7 @@ module Cucumber
         sprintf("#<%s:0x%x>", modules.join('+'), self.object_id)
       end
 
+      # see {#inspect}
       def to_s
         inspect
       end

data/lib/cucumber/rb_support/snippet.rb

@@ -0,0 +1,108 @@
+module Cucumber
+  module RbSupport
+    module Snippet
+
+      ARGUMENT_PATTERNS = ['"(.*?)"', '(\d+)']
+
+      class BaseSnippet
+
+        def initialize(code_keyword, pattern, multiline_argument_class)
+          @number_of_arguments = 0
+          @code_keyword = code_keyword
+          @pattern = replace_and_count_capturing_groups(pattern)
+          @multiline_argument_class = multiline_argument_class
+        end
+
+        def to_s
+          "#{step} #{do_block}"
+        end
+
+        def step
+          "#{code_keyword}#{typed_pattern}"
+        end
+
+        def self.cli_option_string(type)
+          "%-7s: %-28s e.g. %s" % [type, description, example]
+        end
+
+        private
+
+        attr_reader :code_keyword, :pattern, :multiline_argument_class, :number_of_arguments
+
+        def replace_and_count_capturing_groups(pattern)
+          modified_pattern = ::Regexp.escape(pattern).gsub('\ ', ' ').gsub('/', '\/')
+
+          ARGUMENT_PATTERNS.each do |argument_pattern|
+            modified_pattern.gsub!(::Regexp.new(argument_pattern), argument_pattern)
+            @number_of_arguments += modified_pattern.scan(argument_pattern).length
+          end
+
+          modified_pattern
+        end
+
+        def do_block
+          do_block = ""
+          do_block << "do#{arguments}\n"
+          do_block << multiline_comment if multiline_argument_class?
+          do_block << "  pending # express the regexp above with the code you wish you had\n"
+          do_block << "end"
+          do_block
+        end
+
+        def arguments
+          block_args = (0...number_of_arguments).map { |n| "arg#{n+1}" }
+
+          if multiline_argument_class
+            block_args << multiline_argument_class.default_arg_name
+          end
+
+          block_args.empty? ? "" : " |#{block_args.join(", ")}|"
+        end
+
+        def multiline_comment
+          "  # #{multiline_argument_class.default_arg_name} is a #{multiline_argument_class.to_s}\n"
+        end
+
+        def multiline_argument_class?
+          multiline_argument_class == Ast::Table
+        end
+
+        def self.example
+          new("Given", "missing step", nil).step
+        end
+
+      end
+
+      class Regexp < BaseSnippet
+        def typed_pattern
+          "(/^#{pattern}$/)"
+        end
+
+        def self.description
+          "Snippets with parentheses"
+        end
+      end
+
+      class Classic < BaseSnippet
+        def typed_pattern
+          " /^#{pattern}$/"
+        end
+
+        def self.description
+          "Snippets without parentheses. Note that these cause a warning from modern versions of Ruby."
+        end
+      end
+
+      class Percent < BaseSnippet
+        def typed_pattern
+          " %r{^#{pattern}$}"
+        end
+
+        def self.description
+          "Snippets with percent regexp"
+        end
+      end
+
+    end
+  end
+end

data/lib/cucumber/runtime.rb

@@ -3,6 +3,7 @@ require 'multi_json'
 require 'gherkin/rubify'
 require 'gherkin/i18n'
 require 'cucumber/configuration'
+require 'cucumber/load_path'
 require 'cucumber/language_support/language_methods'
 require 'cucumber/formatter/duration'
 require 'cucumber/runtime/user_interface'

data/lib/cucumber/runtime/support_code.rb

@@ -49,7 +49,7 @@ module Cucumber
       #   })
       def invoke_steps(steps_text, i18n, file_colon_line)
         file, line = file_colon_line.split(':')
-        parser = Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps')
+        parser = Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps', false, i18n.iso_code)
         parser.parse(steps_text, file, line.to_i)
       end
 
@@ -99,7 +99,7 @@ module Cucumber
       def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
         load_programming_language('rb') if unknown_programming_language?
         @programming_languages.map do |programming_language|
-          programming_language.snippet_text(step_keyword, step_name, multiline_arg_class)
+          programming_language.snippet_text(step_keyword, step_name, multiline_arg_class, @configuration.snippet_type)
         end.join("\n")
       end
 

data/lib/cucumber/unit.rb

@@ -0,0 +1,11 @@
+module Cucumber
+  class Unit
+    def initialize(step_collection)
+      @step_collection = step_collection
+    end
+
+    def step_count
+      @step_collection.length
+    end
+  end
+end

data/lib/cucumber/wire_support/wire_language.rb

@@ -26,7 +26,7 @@ module Cucumber
         @connections << Connection.new(config)
       end
 
-      def snippet_text(code_keyword, step_name, multiline_arg_class)
+      def snippet_text(code_keyword, step_name, multiline_arg_class, snippet_type)
         snippets = @connections.map do |remote|
           remote.snippet_text(code_keyword, step_name, multiline_arg_class.to_s)
         end

data/spec/cucumber/ast/background_spec.rb

@@ -5,6 +5,7 @@ require 'cucumber/rb_support/rb_language'
 module Cucumber
   module Ast
     describe Background do
+      let(:language) { stub.as_null_object }
 
       before do
         extend(Cucumber::RbSupport::RbDsl)
@@ -21,24 +22,27 @@ module Cucumber
 
         @visitor = TreeWalker.new(@runtime)
 
-        @feature = mock('feature', :visit? => true).as_null_object
+        @feature = mock('feature', :visit? => true, :feature_elements => []).as_null_object
       end
 
       it "should execute Before blocks before background steps" do
         background = Background.new(
+          language,
+          Location.new('foo.feature', 2),
           comment=Comment.new(''),
-          line=2,
           keyword="",
           title="",
           description="",
           steps=[
-            Step.new(7, "Given", "y is 5")
+            Step.new(language,Location.new('foo.feature', 7), "Given", "y is 5")
           ])
 
         scenario = Scenario.new(
+          language,
           background,
           comment=Comment.new(""),
           tags=Tags.new(98,[]),
+          feature_tags=Tags.new(1,[]),
           line=99,
           keyword="",
           title="",
@@ -54,8 +58,9 @@ module Cucumber
       describe "should respond to #name" do
         it "with a value" do
           background = Background.new(
+            language,
+            Location.new('foo.feature', 2),
             comment=Comment.new(''),
-            line=2,
             keyword="",
             title="background name",
             description="",
@@ -65,6 +70,7 @@ module Cucumber
         end
         it "without a value" do
           background = Background.new(
+            language,
             comment=Comment.new(''),
             line=2,
             keyword="",
@@ -86,13 +92,14 @@ module Cucumber
         it "should state that the background has failed" do
           # Assign
           background = Background.new(
+            language,
+            Location.new('foo.feature', 2),
             comment=Comment.new(''),
-            line=2,
             keyword="",
             title="",
             description="",
             steps=[
-              Step.new(7, "Given", "y is 5")
+              Step.new(language, Location.new('foo.feature', 7), "Given", "y is 5")
             ])
           background.feature = @feature