cucumber 2.0.2 → 2.1.0

data/lib/cucumber/formatter/legacy_api/ast.rb

@@ -104,7 +104,7 @@ module Cucumber
                                     :embeddings) do
           extend Forwardable
 
-          def_delegators :step, :keyword, :name, :multiline_arg, :location, :gherkin_statement
+          def_delegators :step, :keyword, :name, :multiline_arg, :location
 
           def accept(formatter)
             formatter.before_step(self)
@@ -252,7 +252,7 @@ module Cucumber
           def keyword
             # This method is only called when used for the scenario name line with
             # the expand option, and on that line the keyword is "Scenario"
-            language.keywords('scenario')[0]
+            language.scenario_keywords[0]
           end
         end
 

data/lib/cucumber/formatter/legacy_api/runtime_facade.rb

@@ -1,3 +1,5 @@
+require 'cucumber/gherkin/i18n'
+
 module Cucumber
   module Formatter
     module LegacyApi
@@ -9,7 +11,7 @@ module Cucumber
         end
 
         def snippet_text(step_keyword, step_name, multiline_arg) #:nodoc:
-          support_code.snippet_text(::Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg)
+          support_code.snippet_text(Cucumber::Gherkin::I18n.code_keyword_for(step_keyword).strip, step_name, multiline_arg)
         end
 
         def unknown_programming_language?

data/lib/cucumber/formatter/pretty.rb

@@ -1,7 +1,7 @@
 require 'fileutils'
 require 'cucumber/formatter/console'
 require 'cucumber/formatter/io'
-require 'gherkin/formatter/escaping'
+require 'cucumber/gherkin/formatter/escaping'
 
 module Cucumber
   module Formatter
@@ -16,12 +16,12 @@ module Cucumber
       include FileUtils
       include Console
       include Io
-      include Gherkin::Formatter::Escaping
+      include Cucumber::Gherkin::Formatter::Escaping
       attr_writer :indent
       attr_reader :runtime
 
       def initialize(runtime, path_or_io, options)
-        @runtime, @io, @options = runtime, ensure_io(path_or_io, "pretty"), options
+        @runtime, @io, @options = runtime, ensure_io(path_or_io), options
         @exceptions = []
         @indent = 0
         @prefixes = options[:prefixes] || {}
@@ -105,9 +105,7 @@ module Cucumber
       def examples_name(keyword, name)
         @io.puts unless @visiting_first_example_name
         @visiting_first_example_name = false
-        names = name.strip.empty? ? [name.strip] : name.split("\n")
-        @io.puts("    #{keyword}: #{names[0]}")
-        names[1..-1].each {|s| @io.puts "      #{s}" } unless names.empty?
+        @io.puts("    #{keyword}: #{name}")
         @io.flush
         @indent = 6
         @scenario_indent = 6
@@ -231,7 +229,7 @@ module Cucumber
           @io.print(format_string(line_comment, :comment))
         end
         @io.puts
-        names[1..-1].each {|s| @io.puts "    #{s}"}
+        names[1..-1].each {|s| @io.puts "#{s}"}
         @io.flush
       end
 

data/lib/cucumber/formatter/progress.rb

@@ -12,7 +12,7 @@ module Cucumber
       attr_reader :runtime
 
       def initialize(runtime, path_or_io, options)
-        @runtime, @io, @options = runtime, ensure_io(path_or_io, "progress"), options
+        @runtime, @io, @options = runtime, ensure_io(path_or_io), options
         @previous_step_keyword = nil
         @snippets_input = []
         @total_duration = 0

data/lib/cucumber/formatter/rerun.rb

@@ -6,7 +6,7 @@ module Cucumber
       include Formatter::Io
 
       def initialize(runtime, path_or_io, options)
-        @io = ensure_io(path_or_io, "rerun")
+        @io = ensure_io(path_or_io)
         @failures = {}
         @options = options
       end

data/lib/cucumber/formatter/steps.rb

@@ -4,7 +4,7 @@ module Cucumber
     class Steps
 
       def initialize(runtime, path_or_io, options)
-        @io = ensure_io(path_or_io, "steps")
+        @io = ensure_io(path_or_io)
         @options = options
         @step_definition_files = collect_steps(runtime)
       end

data/lib/cucumber/formatter/usage.rb

@@ -12,26 +12,30 @@ module Cucumber
 
       def initialize(runtime, path_or_io, options)
         @runtime = runtime
-        @io = ensure_io(path_or_io, "usage")
+        @io = ensure_io(path_or_io)
         @options = options
         @stepdef_to_match = Hash.new { |h, stepdef_key| h[stepdef_key] = [] }
         @total_duration = 0
+        @matches = {}
+        runtime.configuration.on_event :step_match do |event|
+          @matches[event.test_step.source] = event.step_match
+        end
       end
 
       def after_test_step(test_step, result)
         return if HookQueryVisitor.new(test_step).hook?
 
-        step_match = @runtime.step_match(test_step.source.last.name)
+        step_match = @matches[test_step.source]
         step_definition = step_match.step_definition
-        stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
-        unless @stepdef_to_match[stepdef_key].map { |key| key[:file_colon_line] }.include? test_step.location
+        stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.location)
+        unless @stepdef_to_match[stepdef_key].map { |key| key[:location] }.include? test_step.location
           duration = DurationExtractor.new(result).result_duration
 
           @stepdef_to_match[stepdef_key] << {
             keyword: test_step.source.last.keyword,
             step_match: step_match,
             status: result.to_sym,
-            file_colon_line: test_step.location,
+            location: test_step.location,
             duration: duration
           }
         end
@@ -68,7 +72,7 @@ module Cucumber
         @io.print format_string(stepdef_key.regexp_source, stepdef_key.status)
         if @options[:source]
           indent = max_length - stepdef_key.regexp_source.unpack('U*').length
-          line_comment = "   # #{stepdef_key.file_colon_line}".indent(indent)
+          line_comment = "   # #{stepdef_key.location}".indent(indent)
           @io.print(format_string(line_comment, :comment))
         end
         @io.puts
@@ -81,7 +85,7 @@ module Cucumber
           @io.print format_step(step[:keyword], step[:step_match], step[:status], nil)
           if @options[:source]
             indent = max_length - (step[:keyword].unpack('U*').length + step[:step_match].format_args.unpack('U*').length)
-            line_comment = " # #{step[:file_colon_line]}".indent(indent)
+            line_comment = " # #{step[:location]}".indent(indent)
             @io.print(format_string(line_comment, :comment))
           end
           @io.puts
@@ -123,7 +127,7 @@ module Cucumber
 
       def add_unused_stepdefs
         @runtime.unmatched_step_definitions.each do |step_definition|
-          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
+          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.location)
           @stepdef_to_match[stepdef_key] = []
         end
       end

data/lib/cucumber/gherkin/data_table_parser.rb

@@ -0,0 +1,23 @@
+require 'gherkin3/token_scanner'
+require 'gherkin3/token_matcher'
+
+module Cucumber
+  module Gherkin
+    class DataTableParser
+      def initialize(builder)
+        @builder = builder
+      end
+      def parse(text)
+        scanner = ::Gherkin3::TokenScanner.new(text)
+        matcher = ::Gherkin3::TokenMatcher.new
+        token = scanner.read
+        until matcher.match_EOF(token) do
+          if matcher.match_TableRow(token)
+            @builder.row(token.matched_items.map { |cell_item| cell_item.text })
+          end
+          token = scanner.read
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/gherkin/formatter/ansi_escapes.rb

@@ -0,0 +1,99 @@
+module Cucumber
+module Gherkin
+  module Formatter
+    # Defines aliases for ANSI coloured output. Default colours can be overridden by defining
+    # a <tt>GHERKIN_COLORS</tt> variable in your shell, very much like how you can
+    # tweak the familiar POSIX command <tt>ls</tt> with
+    # $LSCOLORS: http://linux-sxs.org/housekeeping/lscolors.html
+    #
+    # The colours that you can change are:
+    #
+    # <tt>undefined</tt>::     defaults to <tt>yellow</tt>
+    # <tt>pending</tt>::       defaults to <tt>yellow</tt>
+    # <tt>pending_arg</tt>::   defaults to <tt>yellow,bold</tt>
+    # <tt>executing</tt>::     defaults to <tt>grey</tt>
+    # <tt>executing_arg</tt>:: defaults to <tt>grey,bold</tt>
+    # <tt>failed</tt>::        defaults to <tt>red</tt>
+    # <tt>failed_arg</tt>::    defaults to <tt>red,bold</tt>
+    # <tt>passed</tt>::        defaults to <tt>green</tt>
+    # <tt>passed_arg</tt>::    defaults to <tt>green,bold</tt>
+    # <tt>outline</tt>::       defaults to <tt>cyan</tt>
+    # <tt>outline_arg</tt>::   defaults to <tt>cyan,bold</tt>
+    # <tt>skipped</tt>::       defaults to <tt>cyan</tt>
+    # <tt>skipped_arg</tt>::   defaults to <tt>cyan,bold</tt>
+    # <tt>comment</tt>::       defaults to <tt>grey</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
+    # steps to be white instead of green. Examples:
+    #
+    #   export GHERKIN_COLORS="passed=white"
+    #   export GHERKIN_COLORS="passed=white,bold:passed_arg=white,bold,underline"
+    #
+    # (If you're on Windows, use SET instead of export).
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
+    #
+    # Although not listed, you can also use <tt>grey</tt>
+    module AnsiEscapes
+      COLORS = {
+        'black'   => "\e[30m",
+        'red'     => "\e[31m",
+        'green'   => "\e[32m",
+        'yellow'  => "\e[33m",
+        'blue'    => "\e[34m",
+        'magenta' => "\e[35m",
+        'cyan'    => "\e[36m",
+        'white'   => "\e[37m",
+        'grey'    => "\e[90m",
+        'bold'    => "\e[1m"
+      }
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_arg/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'executing' => 'grey',
+        'failed'    => 'red',
+        'passed'    => 'green',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comments'  => 'grey',
+        'tag'       => 'cyan'
+      })
+
+      if ENV['GHERKIN_COLORS'] # Example: export GHERKIN_COLORS="passed=red:failed=yellow"
+        ENV['GHERKIN_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0]] = a[1]
+        end
+      end
+
+      ALIASES.keys.each do |key|
+        define_method(key) do
+          ALIASES[key].split(',').map{|color| COLORS[color]}.join('')
+        end
+
+        define_method("#{key}_arg") do
+          ALIASES["#{key}_arg"].split(',').map{|color| COLORS[color]}.join('')
+        end
+      end
+      
+      def reset
+        "\e[0m"
+      end
+
+      def up(n)
+        "\e[#{n}A"
+      end
+
+      extend self
+    end
+  end
+end
+end

data/lib/cucumber/gherkin/formatter/argument.rb

@@ -0,0 +1,17 @@
+require 'cucumber/gherkin/formatter/hashable'
+
+module Cucumber
+module Gherkin
+  module Formatter
+    class Argument < Hashable
+      #native_impl('gherkin')
+      attr_reader :offset, :val
+
+      # Creates a new Argument that starts at character offset +offset+ with value +val+
+      def initialize(offset, val)
+        @offset, @val = offset, val
+      end
+    end
+  end
+end
+end

data/lib/cucumber/gherkin/formatter/escaping.rb

@@ -0,0 +1,17 @@
+module Cucumber
+module Gherkin
+  module Formatter
+    module Escaping
+      # Escapes a pipes and backslashes:
+      #
+      # * | becomes \|
+      # * \ becomes \\
+      #
+      # This is used in the pretty formatter.
+      def escape_cell(s)
+        s.gsub(/\\(?!\|)/, "\\\\\\\\").gsub(/\n/, "\\n").gsub(/\|/, "\\|")
+      end
+    end
+  end
+end
+end

data/lib/cucumber/gherkin/formatter/hashable.rb

@@ -0,0 +1,27 @@
+module Cucumber
+module Gherkin
+  module Formatter
+    class Hashable
+      def to_hash
+        ivars = instance_variables
+        # When tests are runn with therubyracer (JavaScript), an extra field might
+        # exist - added by Ref::WeakReference
+        # https://github.com/bdurand/ref/blob/master/lib/ref/weak_reference/pure_ruby.rb
+        # Remove it - we don't want it in the JSON.
+        ivars.delete(:@__weak_backreferences__)
+        ivars.inject({}) do |hash, ivar|
+          value = instance_variable_get(ivar)
+          value = value.to_hash if value.respond_to?(:to_hash)
+          if Array === value
+            value = value.map do |e|
+              e.respond_to?(:to_hash) ? e.to_hash : e
+            end
+          end
+          hash[ivar[1..-1]] = value unless [[], nil].index(value)
+          hash
+        end
+      end
+    end
+  end
+end
+end

data/lib/cucumber/gherkin/i18n.rb

@@ -0,0 +1,15 @@
+module Cucumber
+  module Gherkin
+    module I18n
+      class << self
+        def code_keyword_for(gherkin_keyword)
+          gherkin_keyword.gsub(/[\s',!]/, '').strip
+        end
+
+        def code_keywords_for(gherkin_keywords)
+          gherkin_keywords.reject { |kw| kw == '* ' }.map { |kw| code_keyword_for(kw) }
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/gherkin/steps_parser.rb

@@ -0,0 +1,41 @@
+require 'gherkin3/token_scanner'
+require 'gherkin3/token_matcher'
+require 'gherkin3/ast_builder'
+require 'gherkin3/parser'
+
+module Cucumber
+  module Gherkin
+    class StepsParser
+      def initialize(builder, language)
+        @builder = builder
+        @language = language
+      end
+      def parse(text)
+        ast_builder = ::Gherkin3::AstBuilder.new
+        token_matcher = ::Gherkin3::TokenMatcher.new
+        token_matcher.send(:change_dialect, @language, nil) unless @language == 'en'
+        context = ::Gherkin3::ParserContext.new(
+          ::Gherkin3::TokenScanner.new(text),
+          token_matcher,
+          [],
+          []
+          )
+        parser = ::Gherkin3::Parser.new(ast_builder)
+
+        parser.start_rule(context, :ScenarioDefinition)
+        parser.start_rule(context, :Scenario)
+        scenario = ast_builder.current_node
+        state = 12
+        token = nil
+        begin
+          token = parser.read_token(context)
+          state = parser.match_token(state, token, context)
+        end until(token.eof?)
+
+        raise CompositeParserException.new(context.errors) if context.errors.any?
+
+        @builder.steps(ast_builder.get_steps(scenario))
+      end
+    end
+  end
+end

data/lib/cucumber/language_support/language_methods.rb

@@ -5,7 +5,8 @@ module Cucumber
   module LanguageSupport
     module LanguageMethods
 
-      def after_configuration(configuration)
+      def after_configuration(cli_configuration)
+        configuration = Configuration.new(cli_configuration)
         hooks[:after_configuration].each do |hook|
           hook.invoke('AfterConfiguration', configuration)
         end
@@ -40,12 +41,12 @@ module Cucumber
         available_step_definition_hash.keys - invoked_step_definition_hash.keys
       end
 
-      def available_step_definition(regexp_source, file_colon_line)
-        available_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      def available_step_definition(regexp_source, location)
+        available_step_definition_hash[StepDefinitionLight.new(regexp_source, location)] = nil
       end
 
-      def invoked_step_definition(regexp_source, file_colon_line)
-        invoked_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
+      def invoked_step_definition(regexp_source, location)
+        invoked_step_definition_hash[StepDefinitionLight.new(regexp_source, location)] = nil
       end
 
       private

data/lib/cucumber/multiline_argument.rb

@@ -1,11 +1,9 @@
 require 'delegate'
 require 'cucumber/multiline_argument/data_table'
 require 'cucumber/multiline_argument/doc_string'
-require 'gherkin/rubify'
 
 module Cucumber
   module MultilineArgument
-    extend Gherkin::Rubify
 
     class << self
       def from_core(node)
@@ -14,7 +12,6 @@ module Cucumber
 
       def from(argument, location=nil)
         location ||= Core::Ast::Location.of_caller
-        argument = rubify(argument)
         case argument
         when String
           doc_string(argument, 'text/plain', location)