cucumber 2.1.0 → 2.2.0

data/lib/cucumber/running_test_case.rb

@@ -1,4 +1,5 @@
 require 'delegate'
+require 'cucumber/deprecate'
 
 module Cucumber
   # Represents the current status of a running test case.
@@ -94,7 +95,10 @@ module Cucumber
       end
 
       def skip_invoke!
-        Cucumber.deprecate(self.class.name, __method__, "Call #skip_this_scenario on the World directly")
+        Cucumber.deprecate(
+          "Just call #skip_this_scenario directly",
+          "skip_invoke!",
+          "2.9.9")
         raise Cucumber::Core::Test::Result::Skipped
       end
 

data/lib/cucumber/runtime.rb

@@ -4,13 +4,13 @@ require 'multi_json'
 require 'multi_test'
 require 'cucumber/configuration'
 require 'cucumber/load_path'
-require 'cucumber/language_support/language_methods'
 require 'cucumber/formatter/duration'
 require 'cucumber/file_specs'
 require 'cucumber/filters'
 require 'cucumber/formatter/fanout'
 require 'cucumber/formatter/event_bus_report'
 require 'cucumber/gherkin/i18n'
+require 'cucumber/step_match_search'
 
 module Cucumber
   module FixRuby21Bug9285
@@ -57,12 +57,10 @@ module Cucumber
       @support_code.configure(@configuration)
     end
 
-    def load_programming_language(language)
-      @support_code.load_programming_language(language)
-    end
-
+    require 'cucumber/wire/plugin'
     def run!
       load_step_definitions
+      install_wire_plugin
       fire_after_configuration_hook
       self.visitor = report
 
@@ -90,10 +88,6 @@ module Cucumber
       @support_code.unmatched_step_definitions
     end
 
-    def snippet_text(step_keyword, step_name, multiline_arg) #:nodoc:
-      @support_code.snippet_text(Cucumber::Gherkin::I18n.code_keyword_for(step_keyword).strip, step_name, multiline_arg)
-    end
-
     def begin_scenario(scenario)
       @support_code.fire_hook(:begin_scenario, scenario)
     end
@@ -102,10 +96,6 @@ module Cucumber
       @support_code.fire_hook(:end_scenario)
     end
 
-    def unknown_programming_language?
-      @support_code.unknown_programming_language?
-    end
-
     # Returns Ast::DocString for +string_without_triple_quotes+.
     #
     def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
@@ -213,7 +203,7 @@ module Cucumber
       formatter = factory.new(runtime_facade, path_or_io, options)
       Formatter::LegacyApi::Adapter.new(
         Formatter::IgnoreMissingMessages.new(formatter),
-        results, @support_code, @configuration)
+        results, @configuration)
     end
 
     def legacy_formatter?(factory)
@@ -242,7 +232,9 @@ module Cucumber
         filters << Cucumber::Core::Test::NameFilter.new(name_regexps)
         filters << Cucumber::Core::Test::LocationsFilter.new(filespecs.locations)
         filters << Filters::Quit.new
-        filters << Filters::ActivateSteps.new(@support_code)
+        # TODO: can we just use RbLanguages's step definitions directly?
+        step_match_search = StepMatchSearch.new(@support_code.ruby.method(:step_matches), @configuration)
+        filters << Filters::ActivateSteps.new(step_match_search, @configuration)
         @configuration.filters.each do |filter|
           filters << filter
         end
@@ -262,6 +254,10 @@ module Cucumber
       @support_code.load_files!(files)
     end
 
+    def install_wire_plugin
+      Cucumber::Wire::Plugin.new(@configuration).install if @configuration.all_files_to_load.any? {|f| f =~ %r{\.wire$} }
+    end
+
     def log
       Cucumber.logger
     end

data/lib/cucumber/runtime/support_code.rb

@@ -5,6 +5,7 @@ require 'cucumber/runtime/before_hooks'
 require 'cucumber/runtime/after_hooks'
 require 'cucumber/events/step_match'
 require 'cucumber/gherkin/steps_parser'
+require 'cucumber/step_match_search'
 
 module Cucumber
 
@@ -43,12 +44,11 @@ module Cucumber
 
       include Constantize
 
-      def initialize(user_interface, configuration={})
-        @configuration = Configuration.new(configuration)
+      attr_reader :ruby
+      def initialize(user_interface, configuration=Configuration.default)
+        @configuration = configuration
         @runtime_facade = Runtime::ForProgrammingLanguages.new(self, user_interface)
-        @unsupported_programming_languages = []
-        @programming_languages = []
-        @language_map = {}
+        @ruby = Cucumber::RbSupport::RbLanguage.new(@runtime_facade, @configuration)
       end
 
       def configure(new_configuration)
@@ -73,24 +73,9 @@ module Cucumber
       #
       # 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
+        matches = step_matches(step_name)
+        raise UndefinedDynamicStep, step_name if matches.empty?
+        matches.first.invoke(multiline_argument)
       end
 
       def load_files!(files)
@@ -102,158 +87,65 @@ 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?
+        @ruby.unmatched_step_definitions
       end
 
       def fire_hook(name, *args)
-        @programming_languages.each do |programming_language|
-          programming_language.send(name, *args)
-        end
+        @ruby.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
-        # TODO: move this onto Filters::ActivateSteps
-        @configuration.notify Events::StepMatch.new(test_step, match)
-        if @configuration.dry_run?
-          return SkippingStepMatch.new
-        end
-        match
+        @ruby.step_definitions
       end
 
       def find_after_step_hooks(test_case)
-        ruby = load_programming_language('rb')
         scenario = RunningTestCase.new(test_case)
-        hooks = ruby.hooks_for(:after_step, scenario)
+        hooks = @ruby.hooks_for(:after_step, scenario)
         StepHooks.new hooks
       end
 
       def apply_before_hooks(test_case)
-        ruby = load_programming_language('rb')
         scenario = RunningTestCase.new(test_case)
-        hooks = ruby.hooks_for(:before, scenario)
+        hooks = @ruby.hooks_for(:before, scenario)
         BeforeHooks.new(hooks, scenario).apply_to(test_case)
       end
 
       def apply_after_hooks(test_case)
-        ruby = load_programming_language('rb')
         scenario = RunningTestCase.new(test_case)
-        hooks = ruby.hooks_for(:after, scenario)
+        hooks = @ruby.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|
+        @ruby.hooks_for(:around, scenario).map do |hook|
           Hooks.around_hook(test_case.source) 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(@ruby.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")
+        @ruby.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/step_argument.rb

@@ -0,0 +1,25 @@
+module Cucumber
+  # Defines the location and value of a captured argument from the step
+  # text
+  class StepArgument
+    def self.arguments_from(regexp, step_name)
+      match = regexp.match(step_name)
+      if match
+        n = 0
+        match.captures.map do |val|
+          n += 1
+          offset = match.offset(n)[0]
+          new(offset, val)
+        end
+      else
+        nil
+      end
+    end
+
+    attr_reader :offset, :val
+
+    def initialize(offset, val)
+      @offset, @val = offset, val
+    end
+  end
+end

data/lib/cucumber/step_match.rb

@@ -1,26 +1,20 @@
 require 'cucumber/multiline_argument'
 
 module Cucumber
+
+  # Represents the match found between a Test Step and it's 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, @name_to_match, @step_arguments = step_definition, step_name, step_arguments
     end
 
     def args
       @step_arguments.map{|g| g.val }
     end
 
-    def name
-      @name_to_report
-    end
-
     def activate(test_step)
       test_step.with_action(@step_definition.location) do
         invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
@@ -49,7 +43,7 @@ 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)
+      replace_arguments(@name_to_match, @step_arguments, format, &proc)
     end
 
     def location
@@ -90,7 +84,7 @@ module Cucumber
     end
 
     def inspect #:nodoc:
-      sprintf("#<%s:0x%x>", self.class, self.object_id)
+      "#<#{self.class}: #{location}>"
     end
 
     private

data/lib/cucumber/step_match_search.rb

@@ -0,0 +1,67 @@
+module Cucumber
+  module StepMatchSearch
+    def self.new(search, configuration)
+      CachesStepMatch.new(
+        AssertUnambiguousMatch.new(
+          configuration.guess? ? AttemptToGuessAmbiguousMatch.new(search) : search,
+          configuration
+        )
+      )
+    end
+
+    class AssertUnambiguousMatch
+      def initialize(search, configuration)
+        @search, @configuration = search, configuration
+      end
+
+      def call(step_name)
+        result = @search.call(step_name)
+        raise Cucumber::Ambiguous.new(step_name, result, @configuration.guess?) if result.length > 1
+        result
+      end
+    end
+
+    class AttemptToGuessAmbiguousMatch
+      def initialize(search)
+        @search = search
+      end
+
+      def call(step_name)
+        best_matches(step_name, @search.call(step_name))
+      end
+
+      private
+
+      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
+      end
+
+    end
+
+    require 'delegate'
+    class CachesStepMatch < SimpleDelegator
+      def call(step_name) #:nodoc:
+        @match_cache ||= {}
+
+        matches = @match_cache[step_name]
+        return matches if matches
+
+        @match_cache[step_name] = super(step_name)
+      end
+    end
+
+  end
+end
+