cucumber 2.0.0.rc.5 → 4.0.0.rc.3

data/lib/cucumber/runtime/support_code.rb

@@ -1,55 +1,55 @@
+# frozen_string_literal: true
+
 require 'cucumber/constantize'
 require 'cucumber/runtime/for_programming_languages'
 require 'cucumber/runtime/step_hooks'
 require 'cucumber/runtime/before_hooks'
 require 'cucumber/runtime/after_hooks'
+require 'cucumber/gherkin/steps_parser'
+require 'cucumber/step_match_search'
 
 module Cucumber
-
   class Runtime
-
     class SupportCode
-
       require 'forwardable'
       class StepInvoker
-        include Gherkin::Rubify
-
         def initialize(support_code)
           @support_code = support_code
         end
 
-        def uri(uri)
+        def steps(steps)
+          steps.each { |step| step(step) }
         end
 
         def step(step)
-          location = Core::Ast::Location.of_caller
-          @support_code.invoke_dynamic_step(step.name, multiline_arg(step, location))
-        end
-
-        def eof
+          location = Core::Test::Location.of_caller
+          @support_code.invoke_dynamic_step(step[:text], multiline_arg(step, location))
         end
 
         def multiline_arg(step, location)
-          if argument = step.doc_string
-            MultilineArgument.doc_string(argument.value, argument.content_type, location.on_line(argument.line_range))
+          if !step[:doc_string].nil?
+            MultilineArgument.from(step[:doc_string][:content], location, step[:doc_string][:content_type])
+          elsif !step[:data_table].nil?
+            MultilineArgument::DataTable.from(step[:data_table][:rows].map { |row| row[:cells].map { |cell| cell[:value] } })
           else
-            MultilineArgument.from(step.rows, location)
+            MultilineArgument.from(nil)
           end
         end
       end
 
       include Constantize
 
-      def initialize(user_interface, configuration={})
-        @configuration = Configuration.parse(configuration)
+      attr_reader :registry
+
+      def initialize(user_interface, configuration = Configuration.default)
+        @configuration = configuration
+        # TODO: needs a better name, or inlining its methods
         @runtime_facade = Runtime::ForProgrammingLanguages.new(self, user_interface)
-        @unsupported_programming_languages = []
-        @programming_languages = []
-        @language_map = {}
+        @registry = Cucumber::Glue::RegistryAndMore.new(@runtime_facade, @configuration)
       end
 
       def configure(new_configuration)
-        @configuration = Configuration.parse(new_configuration)
+        @configuration = Configuration.new(new_configuration)
       end
 
       # Invokes a series of steps +steps_text+. Example:
@@ -58,10 +58,9 @@ module Cucumber
       #     Given I have 8 cukes in my belly
       #     Then I should not be thirsty
       #   })
-      def invoke_dynamic_steps(steps_text, i18n, file_colon_line)
-        file, line = file_colon_line.split(':')
-        parser = Gherkin::Parser::Parser.new(StepInvoker.new(self), true, 'steps', false, i18n.iso_code)
-        parser.parse(steps_text, file, line.to_i)
+      def invoke_dynamic_steps(steps_text, iso_code, _location)
+        parser = Cucumber::Gherkin::StepsParser.new(StepInvoker.new(self), iso_code)
+        parser.parse(steps_text)
       end
 
       # @api private
@@ -70,25 +69,10 @@ module Cucumber
       # steps which are compiled into test steps before execution.
       #
       # These are commonly called nested steps.
-      def invoke_dynamic_step(step_name, multiline_argument, location=nil)
-        begin
-          step_match(step_name).invoke(multiline_argument)
-        rescue Undefined => exception
-          raise UndefinedDynamicStep, step_name
-        end
-      end
-
-      # Loads and registers programming language implementation.
-      # Instances are cached, so calling with the same argument
-      # twice will return the same instance.
-      #
-      def load_programming_language(ext)
-        return @language_map[ext] if @language_map[ext]
-        programming_language_class = constantize("Cucumber::#{ext.capitalize}Support::#{ext.capitalize}Language")
-        programming_language = programming_language_class.new(@runtime_facade)
-        @programming_languages << programming_language
-        @language_map[ext] = programming_language
-        programming_language
+      def invoke_dynamic_step(step_name, multiline_argument, _location = nil)
+        matches = step_matches(step_name)
+        raise UndefinedDynamicStep, step_name if matches.empty?
+        matches.first.invoke(multiline_argument)
       end
 
       def load_files!(files)
@@ -100,165 +84,67 @@ module Cucumber
       end
 
       def load_files_from_paths(paths)
-        files = paths.map { |path| Dir["#{path}/**/*"] }.flatten
+        files = paths.map { |path| Dir["#{path}/**/*.rb"] }.flatten
         load_files! files
       end
 
       def unmatched_step_definitions
-        @programming_languages.map do |programming_language|
-          programming_language.unmatched_step_definitions
-        end.flatten
-      end
-
-      def snippet_text(step_keyword, step_name, multiline_arg) #: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, @configuration.snippet_type)
-        end.join("\n")
-      end
-
-      def unknown_programming_language?
-        @programming_languages.empty?
+        registry.unmatched_step_definitions
       end
 
       def fire_hook(name, *args)
-        @programming_languages.each do |programming_language|
-          programming_language.send(name, *args)
-        end
+        # TODO: kill with fire
+        registry.send(name, *args)
       end
 
       def step_definitions
-        @programming_languages.map do |programming_language|
-          programming_language.step_definitions
-        end.flatten
-      end
-
-      def find_match(test_step)
-        begin
-          match = step_match(test_step.name)
-        rescue Cucumber::Undefined
-          return NoStepMatch.new(test_step.source.last, test_step.name)
-        end
-        if @configuration.dry_run?
-          return SkippingStepMatch.new
-        end
-        match
+        registry.step_definitions
       end
 
       def find_after_step_hooks(test_case)
-        ruby = load_programming_language('rb')
         scenario = RunningTestCase.new(test_case)
-
-        action_blocks = ruby.hooks_for(:after_step, scenario).map do |hook|
-          ->(*args) { hook.invoke('AfterStep', args) }
-        end
-        StepHooks.new action_blocks
+        hooks = registry.hooks_for(:after_step, scenario)
+        StepHooks.new hooks
       end
 
       def apply_before_hooks(test_case)
-        ruby = load_programming_language('rb')
+        return test_case if test_case.test_steps.empty?
         scenario = RunningTestCase.new(test_case)
-
-        action_blocks = ruby.hooks_for(:before, scenario).map do |hook|
-          ->(result) { hook.invoke('Before', scenario.with_result(result)) }
-        end
-        BeforeHooks.new(action_blocks).apply_to(test_case)
+        hooks = registry.hooks_for(:before, scenario)
+        BeforeHooks.new(hooks, scenario).apply_to(test_case)
       end
 
       def apply_after_hooks(test_case)
-        ruby = load_programming_language('rb')
+        return test_case if test_case.test_steps.empty?
         scenario = RunningTestCase.new(test_case)
-
-        action_blocks = ruby.hooks_for(:after, scenario).map do |hook|
-          ->(result) { hook.invoke('After', scenario.with_result(result)) }
-        end
-        AfterHooks.new(action_blocks).apply_to(test_case)
+        hooks = registry.hooks_for(:after, scenario)
+        AfterHooks.new(hooks, scenario).apply_to(test_case)
       end
 
       def find_around_hooks(test_case)
-        ruby = load_programming_language('rb')
         scenario = RunningTestCase.new(test_case)
 
-        ruby.hooks_for(:around, scenario).map do |hook|
-          Hooks.around_hook(test_case.source) do |run_scenario|
+        registry.hooks_for(:around, scenario).map do |hook|
+          Hooks.around_hook do |run_scenario|
             hook.invoke('Around', scenario, &run_scenario)
           end
         end
       end
 
-      def step_match(step_name, name_to_report=nil) #:nodoc:
-        @match_cache ||= {}
-
-        match = @match_cache[[step_name, name_to_report]]
-        return match if match
-
-        @match_cache[[step_name, name_to_report]] = step_match_without_cache(step_name, name_to_report)
-      end
-
       private
 
-      def step_match_without_cache(step_name, name_to_report=nil)
-        matches = matches(step_name, name_to_report)
-        raise Undefined.new(step_name) if matches.empty?
-        matches = best_matches(step_name, matches) if matches.size > 1 && guess_step_matches?
-        raise Ambiguous.new(step_name, matches, guess_step_matches?) if matches.size > 1
-        matches[0]
-      end
-
-      def guess_step_matches?
-        @configuration.guess?
-      end
-
-      def matches(step_name, name_to_report)
-        @programming_languages.map do |programming_language|
-          programming_language.step_matches(step_name, name_to_report).to_a
-        end.flatten
-      end
-
-      def best_matches(step_name, step_matches) #:nodoc:
-        no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
-        max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
-        top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
-
-        if no_groups.any?
-          longest_regexp_length = no_groups.map {|step_match| step_match.text_length }.max
-          no_groups.select {|step_match| step_match.text_length == longest_regexp_length }
-        elsif top_groups.any?
-          shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } }.min
-          top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } == shortest_capture_length }
-        else
-          top_groups
-        end
+      def step_matches(step_name)
+        StepMatchSearch.new(registry.method(:step_matches), @configuration).call(step_name)
       end
 
       def load_file(file)
-        if programming_language = programming_language_for(file)
-          log.debug("  * #{file}\n")
-          programming_language.load_code_file(file)
-        else
-          log.debug("  * #{file} [NOT SUPPORTED]\n")
-        end
+        log.debug("  * #{file}\n")
+        registry.load_code_file(file)
       end
 
       def log
         Cucumber.logger
       end
-
-      def programming_language_for(step_def_file)
-        if ext = File.extname(step_def_file)[1..-1]
-          return nil if @unsupported_programming_languages.index(ext)
-          begin
-            load_programming_language(ext)
-          rescue LoadError => e
-            log.debug("Failed to load '#{ext}' programming language for file #{step_def_file}: #{e.message}\n")
-            @unsupported_programming_languages << ext
-            nil
-          end
-        else
-          nil
-        end
-      end
-
     end
   end
 end

data/lib/cucumber/runtime/user_interface.rb

@@ -1,15 +1,12 @@
+# frozen_string_literal: true
+
 require 'timeout'
 
 module Cucumber
   class Runtime
-
     module UserInterface
       attr_writer :visitor
 
-      def visitor=(visitor)
-        @visitor = visitor
-      end
-
       # Output +messages+ alongside the formatted output.
       # This is an alternative to using Kernel#puts - it will display
       # nicer, and in all outputs (in case you use several formatters)
@@ -36,18 +33,15 @@ module Cucumber
         STDOUT.flush
         puts(question)
 
-        if(Cucumber::JRUBY)
-          answer = jruby_gets(timeout_seconds)
-        else
-          answer = mri_gets(timeout_seconds)
-        end
+        answer = if Cucumber::JRUBY
+                   jruby_gets(timeout_seconds)
+                 else
+                   mri_gets(timeout_seconds)
+                 end
 
-        if(answer)
-          puts(answer)
-          answer
-        else
-          raise("Waited for input for #{timeout_seconds} seconds, then timed out.")
-        end
+        raise("Waited for input for #{timeout_seconds} seconds, then timed out.") unless answer
+        puts(answer)
+        answer
       end
 
       # Embed +src+ of MIME type +mime_type+ into the output. The +src+ argument may
@@ -58,16 +52,14 @@ module Cucumber
         @visitor.embed(src, mime_type, label)
       end
 
-    private
+      private
 
       def mri_gets(timeout_seconds)
-        begin
-          Timeout.timeout(timeout_seconds) do
-            STDIN.gets
-          end
-        rescue Timeout::Error
-          nil
+        Timeout.timeout(timeout_seconds) do
+          STDIN.gets
         end
+      rescue Timeout::Error
+        nil
       end
 
       def jruby_gets(timeout_seconds)
@@ -80,6 +72,5 @@ module Cucumber
         answer
       end
     end
-
   end
 end

data/lib/cucumber/step_definition_light.rb

@@ -1,20 +1,24 @@
+# frozen_string_literal: true
+
 module Cucumber
+  # TODO: pointless, ancient, kill with fire.
   # Only used for keeping track of available and invoked step definitions
   # in a way that also works for other programming languages (i.e. cuke4duke)
   # Used for reporting purposes only (usage formatter).
   class StepDefinitionLight
-    attr_reader :regexp_source, :file_colon_line
+    attr_reader :regexp_source, :location
 
-    def initialize(regexp_source, file_colon_line)
-      @regexp_source, @file_colon_line = regexp_source, file_colon_line
+    def initialize(regexp_source, location)
+      @regexp_source = regexp_source
+      @location = location
     end
 
-    def eql?(o)
-      regexp_source == o.regexp_source && file_colon_line == o.file_colon_line
+    def eql?(other)
+      regexp_source == other.regexp_source && location == other.location
     end
 
     def hash
-      regexp_source.hash + 31*file_colon_line.hash
+      regexp_source.hash + 31 * location.to_s.hash
     end
   end
 end

data/lib/cucumber/step_definitions.rb

@@ -1,13 +1,15 @@
+# frozen_string_literal: true
+
 module Cucumber
   class StepDefinitions
     def initialize(configuration = Configuration.default)
-      configuration = Configuration.parse(configuration)
-      @support_code = Runtime::SupportCode.new(nil, false)
+      configuration = Configuration.new(configuration)
+      @support_code = Runtime::SupportCode.new(nil, configuration)
       @support_code.load_files_from_paths(configuration.autoload_code_paths)
     end
 
-    def to_json
-      @support_code.step_definitions.map{|stepdef| stepdef.to_hash}.to_json
+    def to_json(obj = nil)
+      @support_code.step_definitions.map(&:to_hash).to_json(obj)
     end
   end
 end

data/lib/cucumber/step_match.rb

@@ -1,29 +1,29 @@
+# frozen_string_literal: true
+
 require 'cucumber/multiline_argument'
 
 module Cucumber
+  # Represents the match found between a Test Step and its activation
   class StepMatch #:nodoc:
     attr_reader :step_definition, :step_arguments
 
-    # Creates a new StepMatch. The +name_to_report+ argument is what's
-    # reported, unless it's is, in which case +name_to_report+ is used instead.
-    #
-    def initialize(step_definition, name_to_match, name_to_report, step_arguments)
-      raise "name_to_match can't be nil" if name_to_match.nil?
+    def initialize(step_definition, step_name, step_arguments)
       raise "step_arguments can't be nil (but it can be an empty array)" if step_arguments.nil?
-      @step_definition, @name_to_match, @name_to_report, @step_arguments = step_definition, name_to_match, name_to_report, step_arguments
+      @step_definition = step_definition
+      @name_to_match = step_name
+      @step_arguments = step_arguments
     end
 
     def args
-      @step_arguments.map{|g| g.val }
-    end
-
-    def name
-      @name_to_report
+      current_world = @step_definition.registry.current_world
+      @step_arguments.map do |arg|
+        arg.value(current_world)
+      end
     end
 
     def activate(test_step)
-      test_step.with_action do
-        invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
+      test_step.with_action(@step_definition.location) do
+        invoke(MultilineArgument.from_core(test_step.multiline_arg))
       end
     end
 
@@ -48,56 +48,62 @@ module Cucumber
     #
     #   lambda { |param| "[#{param}]" }
     #
-    def format_args(format = lambda{|a| a}, &proc)
-      @name_to_report || replace_arguments(@name_to_match, @step_arguments, format, &proc)
+    def format_args(format = ->(a) { a }, &proc)
+      replace_arguments(@name_to_match, @step_arguments, format, &proc)
+    end
+
+    def location
+      @step_definition.location
     end
 
     def file_colon_line
-      @step_definition.file_colon_line
+      location.to_s
     end
 
     def backtrace_line
-      "#{file_colon_line}:in `#{@step_definition.regexp_source}'"
+      "#{file_colon_line}:in `#{@step_definition.expression}'"
     end
 
     def text_length
-      @step_definition.regexp_source.unpack('U*').length
+      @step_definition.expression.source.to_s.unpack('U*').length
     end
 
-    def replace_arguments(string, step_arguments, format, &proc)
+    def replace_arguments(string, step_arguments, format)
       s = string.dup
       offset = past_offset = 0
       step_arguments.each do |step_argument|
-        next if step_argument.offset.nil? || step_argument.offset < past_offset
+        group = step_argument.group
+        next if group.value.nil? || group.start < past_offset
 
         replacement = if block_given?
-          proc.call(step_argument.val)
-        elsif Proc === format
-          format.call(step_argument.val)
-        else
-          format % step_argument.val
-        end
-
-        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.offset + step_argument.val.length
+                        yield(group.value)
+                      elsif Proc == format.class
+                        format.call(group.value)
+                      else
+                        format % group.value
+                      end
+
+        s[group.start + offset, group.value.length] = replacement
+        offset += replacement.unpack('U*').length - group.value.unpack('U*').length
+        past_offset = group.start + group.value.length
       end
       s
     end
 
     def inspect #:nodoc:
-      sprintf("#<%s:0x%x>", self.class, self.object_id)
+      "#<#{self.class}: #{location}>"
     end
 
     private
+
     def deep_clone_args
-      Marshal.load( Marshal.dump( args ) )
+      Marshal.load(Marshal.dump(args))
     end
   end
 
   class SkippingStepMatch
     def activate(test_step)
-      return test_step.with_action { raise Core::Test::Result::Skipped.new }
+      test_step.with_action { raise Core::Test::Result::Skipped }
     end
   end
 
@@ -109,13 +115,17 @@ module Cucumber
       @name = name
     end
 
-    def format_args(*args)
+    def format_args(*_args)
       @name
     end
 
+    def location
+      raise "No location for #{@step}" unless @step.location
+      @step.location
+    end
+
     def file_colon_line
-      raise "No file:line for #{@step}" unless @step.file_colon_line
-      @step.file_colon_line
+      location.to_s
     end
 
     def backtrace_line
@@ -123,7 +133,7 @@ module Cucumber
     end
 
     def text_length
-      @step.text_length
+      @step.text.length
     end
 
     def step_arguments
@@ -132,7 +142,17 @@ module Cucumber
 
     def activate(test_step)
       # noop
-      return test_step
+      test_step
+    end
+  end
+
+  class AmbiguousStepMatch
+    def initialize(error)
+      @error = error
+    end
+
+    def activate(test_step)
+      test_step.with_action { raise @error }
     end
   end
 end