cucumber 1.3.10 → 2.0.0

data/lib/cucumber/runtime/for_programming_languages.rb

@@ -1,4 +1,6 @@
 require 'forwardable'
+require 'cucumber/core/ast/doc_string'
+require 'cucumber/core/ast/data_table'
 
 module Cucumber
   class Runtime
@@ -21,11 +23,11 @@ module Cucumber
         :step_match
 
       def_delegators :@support_code,
-        :invoke_steps,
-        :invoke,
+        :invoke_dynamic_steps,
+        :invoke_dynamic_step,
         :load_programming_language
 
-      # Returns a Cucumber::Ast::Table for +text_or_table+, which can either
+      # Returns a Cucumber::MultilineArgument::DataTable for +text_or_table+, which can either
       # be a String:
       #
       #   table(%{
@@ -42,18 +44,20 @@ module Cucumber
       #     %w{ CUC-101 Peeler      22     }
       #   ])
       #
-      def table(text_or_table, file=nil, line_offset=0)
-        if Array === text_or_table
-          Ast::Table.new(text_or_table)
+      def table(text_or_table, file=nil, line=0)
+        if !file
+          location = Core::Ast::Location.of_caller
         else
-          Ast::Table.parse(text_or_table, file, line_offset)
+          location = Core::Ast::Location.new(file, line)
         end
+        MultilineArgument::DataTable.from(text_or_table, location)
       end
 
-      # Returns Ast::DocString for +string_without_triple_quotes+.
+      # Returns a Cucumber::MultilineArgument::DocString for +body+.
       #
-      def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-        Ast::DocString.new(string_without_triple_quotes,content_type)
+      def doc_string(body, content_type='', line_offset=0)
+        location = Core::Ast::Location.of_caller
+        MultilineArgument.doc_string(body, content_type, location)
       end
     end
   end

data/lib/cucumber/runtime/step_hooks.rb

@@ -0,0 +1,22 @@
+module Cucumber
+  class Runtime
+    class StepHooks
+      def initialize(after)
+        @after = after
+      end
+
+      def apply(test_steps)
+        test_steps.flat_map do |test_step|
+          [test_step] + after_step_hooks(test_step)
+        end
+      end
+
+      private
+      def after_step_hooks(test_step)
+        @after.map do |action_block|
+          Hooks.after_step_hook(test_step.source, &action_block)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/support_code.rb

@@ -1,6 +1,8 @@
 require 'cucumber/constantize'
-require 'cucumber/ast/multiline_argument'
 require 'cucumber/runtime/for_programming_languages'
+require 'cucumber/runtime/step_hooks'
+require 'cucumber/runtime/before_hooks'
+require 'cucumber/runtime/after_hooks'
 
 module Cucumber
 
@@ -20,11 +22,20 @@ module Cucumber
         end
 
         def step(step)
-          @support_code.invoke(step.name, Ast::MultilineArgument.from(step.doc_string || step.rows))
+          location = Core::Ast::Location.of_caller
+          @support_code.invoke_dynamic_step(step.name, multiline_arg(step, location))
         end
 
         def eof
         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))
+          else
+            MultilineArgument.from(step.rows, location)
+          end
+        end
       end
 
       include Constantize
@@ -47,20 +58,23 @@ module Cucumber
       #     Given I have 8 cukes in my belly
       #     Then I should not be thirsty
       #   })
-      def invoke_steps(steps_text, i18n, file_colon_line)
+      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)
       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.
+      # @api private
+      # This allows users to attempt to find, match and execute steps
+      # from code as the features are running, as opposed to regular
+      # 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 Exception => e
-          e.nested! if Undefined === e
-          raise e
+        rescue Undefined => exception
+          raise UndefinedDynamicStep, step_name
         end
       end
 
@@ -96,10 +110,10 @@ module Cucumber
         end.flatten
       end
 
-      def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+      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_class, @configuration.snippet_type)
+          programming_language.snippet_text(step_keyword, step_name, multiline_arg, @configuration.snippet_type)
         end.join("\n")
       end
 
@@ -113,22 +127,65 @@ module Cucumber
         end
       end
 
-      def around(scenario, block)
-        @programming_languages.reverse.inject(block) do |blk, programming_language|
-          proc do
-            programming_language.around(scenario) do
-              blk.call(scenario)
-            end
-          end
-        end.call
-      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
+      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
+      end
+
+      def apply_before_hooks(test_case)
+        ruby = load_programming_language('rb')
+        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)
+      end
+
+      def apply_after_hooks(test_case)
+        ruby = load_programming_language('rb')
+        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)
+      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|
+            hook.invoke('Around', scenario, &run_scenario)
+          end
+        end
+      end
+
       def step_match(step_name, name_to_report=nil) #:nodoc:
         @match_cache ||= {}
 

data/lib/cucumber/runtime/user_interface.rb

@@ -6,6 +6,10 @@ module Cucumber
     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)

data/lib/cucumber/runtime.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'fileutils'
 require 'multi_json'
 require 'multi_test'
@@ -7,31 +8,53 @@ require 'cucumber/configuration'
 require 'cucumber/load_path'
 require 'cucumber/language_support/language_methods'
 require 'cucumber/formatter/duration'
-require 'cucumber/runtime/user_interface'
-require 'cucumber/runtime/features_loader'
-require 'cucumber/runtime/results'
-require 'cucumber/runtime/support_code'
+require 'cucumber/file_specs'
+require 'cucumber/filters'
+require 'cucumber/formatter/fanout'
 
 module Cucumber
-  # This is the meaty part of Cucumber that ties everything together.
+  module FixRuby21Bug9285
+    def message
+      String(super).gsub("@ rb_sysopen ", "")
+    end
+  end
+
+  class FileException < Exception
+    attr :path
+
+    def initialize(original_exception, path)
+      super(original_exception)
+      @path = path
+    end
+  end
+
+  class FileNotFoundException < FileException
+  end
+
+  class FeatureFolderNotFoundException < FileException
+    include FixRuby21Bug9285 if Cucumber::RUBY_2_1 || Cucumber::RUBY_2_2
+  end
+
+  require 'cucumber/core'
+  require 'cucumber/runtime/user_interface'
+  require 'cucumber/runtime/support_code'
   class Runtime
-    attr_reader :results
+    attr_reader :results, :support_code, :configuration
 
+    include Cucumber::Core
     include Formatter::Duration
     include Runtime::UserInterface
 
     def initialize(configuration = Configuration.default)
-      @current_scenario = nil
       @configuration = Configuration.parse(configuration)
       @support_code = SupportCode.new(self, @configuration)
-      @results = Results.new(@configuration)
+      @results = Formatter::LegacyApi::Results.new
     end
 
-    # Allows you to take an existing runtime and change it's configuration
+    # Allows you to take an existing runtime and change its configuration
     def configure(new_configuration)
       @configuration = Configuration.parse(new_configuration)
       @support_code.configure(@configuration)
-      @results.configure(@configuration)
     end
 
     def load_programming_language(language)
@@ -40,21 +63,19 @@ module Cucumber
 
     def run!
       load_step_definitions
-      disable_minitest_test_unit_autorun
       fire_after_configuration_hook
+      self.visitor = report
 
-      tree_walker = @configuration.build_tree_walker(self)
-      self.visitor = tree_walker # Ugly circular dependency, but needed to support World#puts
-
-      tree_walker.visit_features(features)
+      receiver = Test::Runner.new(report)
+      compile features, receiver, filters
     end
 
     def features_paths
       @configuration.paths
     end
 
-    def step_visited(step) #:nodoc:
-      @results.step_visited(step)
+    def dry_run?
+      @configuration.dry_run?
     end
 
     def scenarios(status = nil)
@@ -73,110 +94,147 @@ module Cucumber
       @support_code.unmatched_step_definitions
     end
 
-    def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
-      @support_code.snippet_text(Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg_class)
+    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)
     end
 
-    def with_hooks(scenario, skip_hooks=false)
-      around(scenario, skip_hooks) do
-        before_and_after(scenario, skip_hooks) do
-          yield scenario
-        end
-      end
+    def begin_scenario(scenario)
+      @support_code.fire_hook(:begin_scenario, scenario)
     end
 
-    def around(scenario, skip_hooks=false, &block) #:nodoc:
-      if skip_hooks
-        yield
-        return
-      end
+    def end_scenario(scenario)
+      @support_code.fire_hook(:end_scenario)
+    end
 
-      @support_code.around(scenario, block)
+    def unknown_programming_language?
+      @support_code.unknown_programming_language?
     end
 
-    def before_and_after(scenario, skip_hooks=false) #:nodoc:
-      before(scenario) unless skip_hooks
-      yield scenario
-      after(scenario) unless skip_hooks
-      @results.scenario_visited(scenario)
+    # Returns Ast::DocString for +string_without_triple_quotes+.
+    #
+    def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
+      location = Core::Ast::Location.of_caller
+      Core::Ast::DocString.new(string_without_triple_quotes, content_type, location)
     end
 
-    def before(scenario) #:nodoc:
-      return if @configuration.dry_run? || @current_scenario
-      @current_scenario = scenario
-      @support_code.fire_hook(:before, scenario)
+  private
+
+    def fire_after_configuration_hook #:nodoc
+      @support_code.fire_hook(:after_configuration, @configuration)
     end
 
-    def after(scenario) #:nodoc:
-      @current_scenario = nil
-      return if @configuration.dry_run?
-      @support_code.fire_hook(:after, scenario)
+    require 'cucumber/core/gherkin/document'
+    def features
+      @features ||= feature_files.map do |path|
+        source = NormalisedEncodingFile.read(path)
+        Cucumber::Core::Gherkin::Document.new(path, source)
+      end
     end
 
-    def after_step #:nodoc:
-      return if @configuration.dry_run?
-      @support_code.fire_hook(:execute_after_step, @current_scenario)
+    def feature_files
+      filespecs.files
     end
 
-    def unknown_programming_language?
-      @support_code.unknown_programming_language?
+    def filespecs
+      @filespecs ||= FileSpecs.new(@configuration.feature_files)
     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)
+    class NormalisedEncodingFile
+      COMMENT_OR_EMPTY_LINE_PATTERN = /^\s*#|^\s*$/ #:nodoc:
+      ENCODING_PATTERN = /^\s*#\s*encoding\s*:\s*([^\s]+)/ #:nodoc:
+
+      def self.read(path)
+        new(path).read
+      end
+
+      def initialize(path)
+        begin
+          @file = File.new(path)
+          set_encoding
+        rescue Errno::EACCES => e
+          raise FileNotFoundException.new(e, File.expand_path(path))
+        rescue Errno::ENOENT => e
+          raise FeatureFolderNotFoundException.new(e, path)
         end
-        File.open(File.join(@configuration.dotcucumber, 'stepdefs.json'), 'w') do |io|
-          io.write(MultiJson.dump(stepdefs, :pretty => true))
+      end
+
+      def read
+        @file.read.encode("UTF-8")
+      end
+
+      private
+
+      def set_encoding
+        @file.each do |line|
+          if ENCODING_PATTERN =~ line
+            @file.set_encoding $1
+            break
+          end
+          break unless COMMENT_OR_EMPTY_LINE_PATTERN =~ line
         end
+        @file.rewind
       end
     end
 
-    # Returns Ast::DocString for +string_without_triple_quotes+.
-    #
-    def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-      Ast::DocString.new(string_without_triple_quotes,content_type)
+    require 'cucumber/formatter/legacy_api/adapter'
+    require 'cucumber/formatter/legacy_api/runtime_facade'
+    require 'cucumber/formatter/legacy_api/results'
+    require 'cucumber/formatter/ignore_missing_messages'
+    require 'cucumber/core/report/summary'
+    def report
+      @report ||= Formatter::Fanout.new([summary_report] + formatters)
     end
 
-  private
+    def summary_report
+      @summary_report ||= Core::Report::Summary.new
+    end
 
-    def fire_after_configuration_hook #:nodoc
-      @support_code.fire_hook(:after_configuration, @configuration)
+    def formatters
+      @formatters ||= @configuration.formatter_factories { |factory, path_or_io, options|
+        results = Formatter::LegacyApi::Results.new
+        runtime_facade = Formatter::LegacyApi::RuntimeFacade.new(results, @support_code, @configuration)
+        formatter = factory.new(runtime_facade, path_or_io, options)
+        Formatter::LegacyApi::Adapter.new(
+          Formatter::IgnoreMissingMessages.new(formatter),
+          results, @support_code, @configuration)
+      }
     end
 
-    def features
-      @loader ||= Runtime::FeaturesLoader.new(
-        @configuration.feature_files,
-        @configuration.filters,
-        @configuration.tag_expression)
-      @loader.features
+    def failure?
+      if @configuration.wip?
+        summary_report.test_cases.total_passed > 0
+      else
+        summary_report.test_cases.total_failed > 0 || summary_report.test_steps.total_failed > 0 ||
+          (@configuration.strict? && (summary_report.test_steps.total_undefined > 0 || summary_report.test_steps.total_pending > 0))
+      end
+    end
+    public :failure?
+
+    require 'cucumber/core/test/filters'
+    def filters
+      tag_expressions = @configuration.tag_expressions
+      name_regexps = @configuration.name_regexps
+      tag_limits = @configuration.tag_limits
+      [].tap do |filters|
+        filters << Filters::Randomizer.new(@configuration.seed) if @configuration.randomize?
+        filters << Filters::TagLimits.new(tag_limits) if tag_limits.any?
+        filters << Cucumber::Core::Test::TagFilter.new(tag_expressions)
+        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)
+        @configuration.filters.each do |filter|
+          filters << filter
+        end
+        unless configuration.dry_run?
+          filters << Filters::ApplyAfterStepHooks.new(@support_code)
+          filters << Filters::ApplyBeforeHooks.new(@support_code)
+          filters << Filters::ApplyAfterHooks.new(@support_code)
+          filters << Filters::ApplyAroundHooks.new(@support_code)
+          # need to do this last so it becomes the first test step
+          filters << Filters::PrepareWorld.new(self)
+        end
+      end
     end
 
     def load_step_definitions
@@ -184,13 +242,10 @@ module Cucumber
       @support_code.load_files!(files)
     end
 
-    def disable_minitest_test_unit_autorun
-      MultiTest.disable_autorun
-    end
-
     def log
       Cucumber.logger
     end
+
   end
 
 end

data/lib/cucumber/step_match.rb

@@ -1,3 +1,5 @@
+require 'cucumber/multiline_argument'
+
 module Cucumber
   class StepMatch #:nodoc:
     attr_reader :step_definition, :step_arguments
@@ -12,16 +14,22 @@ module Cucumber
     end
 
     def args
-      @step_arguments.map{|g| g.val}
+      @step_arguments.map{|g| g.val }
     end
 
     def name
       @name_to_report
     end
 
+    def activate(test_step)
+      test_step.with_action do
+        invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
+      end
+    end
+
     def invoke(multiline_arg)
-      all_args = args
-      all_args << multiline_arg.to_step_definition_arg if multiline_arg
+      all_args = deep_clone_args
+      multiline_arg.append_to(all_args)
       @step_definition.invoke(all_args)
     end
 
@@ -80,6 +88,17 @@ module Cucumber
     def inspect #:nodoc:
       sprintf("#<%s:0x%x>", self.class, self.object_id)
     end
+
+    private
+    def deep_clone_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 }
+    end
   end
 
   class NoStepMatch #:nodoc:
@@ -110,5 +129,10 @@ module Cucumber
     def step_arguments
       []
     end
+
+    def activate(test_step)
+      # noop
+      return test_step
+    end
   end
 end

data/lib/cucumber/term/ansicolor.rb

@@ -78,7 +78,7 @@ module Cucumber
 
 
       def self.included(klass)
-        if version_is_greater_than_18? and klass == String
+        if klass == String
           ATTRIBUTES.delete(:clear)
           ATTRIBUTE_NAMES.delete(:clear)
         end
@@ -105,14 +105,6 @@ module Cucumber
         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