cucumber 2.0.2 → 2.1.0

data/lib/cucumber/events.rb

@@ -0,0 +1,20 @@
+module Cucumber
+
+  # Events tell you what's happening while Cucumber runs your features.
+  #
+  # They're designed to be read-only, appropriate for writing formatters and other
+  # output tools. If you need to be able to influence the result of a scenario, use a hook instead.
+  #
+  # To subscribe to an event, use {Cucumber::Configuration#on_event}
+  #
+  # @example
+  #   AfterConfiguration do |config|
+  #     config.on_event :after_test_step do |event|
+  #       puts event.result
+  #     end
+  #   end
+  module Events
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/events/*.rb'].map(&method(:require))

data/lib/cucumber/events/after_test_case.rb

@@ -0,0 +1,25 @@
+module Cucumber
+  module Events
+
+    # Event fired after a test case has finished executing
+    class AfterTestCase
+
+      # The test case that was just executed.
+      #
+      # @return [Cucumber::Core::Test::Case]
+      attr_reader :test_case
+
+      # The result of executing the test case.
+      #
+      # @return [Cucumber::Core::Test::Result]
+      attr_reader :result
+
+      # @private
+      def initialize(test_case, result)
+        @test_case, @result = test_case, result
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/events/after_test_step.rb

@@ -0,0 +1,30 @@
+module Cucumber
+  module Events
+
+    # Event fired after each test step has been executed
+    class AfterTestStep
+
+      # The test case currently being executed.
+      #
+      # @return [Cucumber::Core::Test::Case]
+      attr_reader :test_case
+
+      # The test step that was just executed.
+      #
+      # @return [Cucumber::Core::Test::Step]
+      attr_reader :test_step
+
+      # The result of executing the test step.
+      #
+      # @return [Cucumber::Core::Test::Result]
+      attr_reader :result
+
+      # @private
+      def initialize(test_case, test_step, result)
+        @test_case, @test_step, @result = test_case, test_step, result
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/events/before_test_case.rb

@@ -0,0 +1,18 @@
+module Cucumber
+  module Events
+
+    # Event fired before a test case is executed
+    class BeforeTestCase
+
+      # The test case about to be executed.
+      #
+      # @return [Cucumber::Core::Test::Case]
+      attr_reader :test_case
+
+      # @private
+      def initialize(test_case)
+        @test_case = test_case
+      end
+    end
+  end
+end

data/lib/cucumber/events/before_test_step.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  module Events
+
+    # Event fired before a test step is executed
+    class BeforeTestStep
+
+      # The test case currently being executed.
+      #
+      # @return [Cucumber::Core::Test::Case]
+      attr_reader :test_case
+
+      # The test step about to be executed.
+      #
+      # @return [Cucumber::Core::Test::Step]
+      attr_reader :test_step
+
+      # @private
+      def initialize(test_case, test_step)
+        @test_case, @test_step = test_case, test_step
+      end
+    end
+  end
+end

data/lib/cucumber/events/bus.rb

@@ -0,0 +1,86 @@
+module Cucumber
+  module Events
+
+    # Event bus
+    #
+    # Implements and in-process pub-sub events broadcaster allowing multiple observers
+    # to subscribe to different events that fire as your tests are executed.
+    #
+    # @private
+    class Bus
+
+      def initialize(default_namespace)
+        @default_namespace = default_namespace.to_s
+        @handlers = {}
+      end
+
+      # Register for an event
+      def register(event_id, handler_object = nil, &handler_proc)
+        handler = handler_proc || handler_object
+        raise ArgumentError.new("Please pass either an object or a handler block") unless handler
+        event_class = parse_event_id(event_id)
+        handlers_for(event_class) << handler
+      end
+
+      # Broadcast an event
+      def notify(event)
+        handlers_for(event.class).each { |handler| handler.call(event) }
+      end
+
+      private
+
+      def handlers_for(event_class)
+        @handlers[event_class.to_s] ||= []
+      end
+
+      def parse_event_id(event_id)
+        case event_id
+        when Class
+          return event_id
+        when String
+          constantize(event_id)
+        else
+          constantize("#{@default_namespace}::#{camel_case(event_id)}")
+        end
+      end
+
+      def camel_case(underscored_name)
+        underscored_name.to_s.split("_").map { |word| word.upcase[0] + word[1..-1] }.join
+      end
+
+      # Thanks ActiveSupport
+      # (Only needed to support Ruby 1.9.3 and JRuby)
+      def constantize(camel_cased_word)
+        names = camel_cased_word.split('::')
+
+        # Trigger a built-in NameError exception including the ill-formed constant in the message.
+        Object.const_get(camel_cased_word) if names.empty?
+
+        # Remove the first blank element in case of '::ClassName' notation.
+        names.shift if names.size > 1 && names.first.empty?
+
+        names.inject(Object) do |constant, name|
+          if constant == Object
+            constant.const_get(name)
+          else
+            candidate = constant.const_get(name)
+            next candidate if constant.const_defined?(name, false)
+            next candidate unless Object.const_defined?(name)
+
+            # Go down the ancestors to check if it is owned directly. The check
+            # stops when we reach Object or the end of ancestors tree.
+            constant = constant.ancestors.inject do |const, ancestor|
+              break const    if ancestor == Object
+              break ancestor if ancestor.const_defined?(name, false)
+              const
+            end
+
+            # owner is in Object, so raise
+            constant.const_get(name, false)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cucumber/events/step_match.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  module Events
+
+    # Event fired when a step is matched to a definition
+    class StepMatch
+
+      # The test step that was matched.
+      #
+      # @return [Cucumber::Core::Test::Step]
+      attr_reader :test_step
+
+      # Information about the matching definition.
+      #
+      # @return [Cucumber::StepMatch]
+      attr_reader :step_match
+
+      # @private
+      def initialize(test_step, step_match)
+        @test_step, @step_match = test_step, step_match
+      end
+    end
+  end
+end

data/lib/cucumber/filters/prepare_world.rb

@@ -25,8 +25,8 @@ module Cucumber
           around_hooks = [init_scenario] + @original_test_case.around_hooks
 
           empty_hook = proc {} #no op - legacy format adapter expects a before hooks
-          file, line = *empty_hook.source_location
-          default_hook = Cucumber::Hooks.before_hook(@original_test_case.source, Cucumber::Core::Ast::Location.new(file, line), &empty_hook)
+          empty_hook_location = Cucumber::Core::Ast::Location.from_source_location(*empty_hook.source_location)
+          default_hook = Cucumber::Hooks.before_hook(@original_test_case.source, empty_hook_location, &empty_hook)
           steps = [default_hook] + @original_test_case.test_steps
 
           @original_test_case.with_around_hooks(around_hooks).with_steps(steps)

data/lib/cucumber/formatter/backtrace_filter.rb

@@ -3,22 +3,23 @@ require 'cucumber/platform'
 
 module Cucumber
   module Formatter
-
-    class BacktraceFilter
-      BACKTRACE_FILTER_PATTERNS = \
+    BACKTRACE_FILTER_PATTERNS = \
       [/vendor\/rails|lib\/cucumber|bin\/cucumber:|lib\/rspec|gems\/|minitest|test\/unit|.gem\/ruby|lib\/ruby/]
-      if(::Cucumber::JRUBY)
-        BACKTRACE_FILTER_PATTERNS << /org\/jruby/
-      end
-      PWD_PATTERN = /#{::Regexp.escape(::Dir.pwd)}\//m
 
+    if(::Cucumber::JRUBY)
+      BACKTRACE_FILTER_PATTERNS << /org\/jruby/
+    end
+
+    class BacktraceFilter
       def initialize(exception)
         @exception = exception
       end
 
       def exception
         return @exception if ::Cucumber.use_full_backtrace
-        @exception.backtrace.each{|line| line.gsub!(PWD_PATTERN, "./")}
+
+        pwd_pattern = /#{::Regexp.escape(::Dir.pwd)}\//m
+        @exception.backtrace.each { |line| line.gsub!(pwd_pattern, "./") }
 
         filtered = (@exception.backtrace || []).reject do |line|
           BACKTRACE_FILTER_PATTERNS.detect { |p| line =~ p }

data/lib/cucumber/formatter/console.rb

@@ -32,7 +32,7 @@ module Cucumber
 
       def format_step(keyword, step_match, status, source_indent)
         comment = if source_indent
-          c = ('# ' + step_match.file_colon_line).indent(source_indent)
+          c = ('# ' + step_match.location.to_s).indent(source_indent)
           format_string(c, :comment)
         else
           ''

data/lib/cucumber/formatter/event_bus_report.rb

@@ -0,0 +1,37 @@
+module Cucumber
+  module Formatter
+
+    # Adapter between Cucumber::Core::Test::Runner's Report API and 
+    # Cucumber's event bus
+    class EventBusReport
+      attr_reader :config
+      private :config
+
+      def initialize(config)
+        @config = config
+      end
+
+      def before_test_case(test_case)
+        @config.notify Events::BeforeTestCase.new(test_case)
+        @test_case = test_case
+      end
+
+      def before_test_step(test_step)
+        @config.notify Events::BeforeTestStep.new(@test_case, test_step)
+      end
+
+      def after_test_step(test_step, result)
+        @config.notify Events::AfterTestStep.new(@test_case, test_step, result)
+      end
+
+      def after_test_case(test_case, result)
+        @config.notify Events::AfterTestCase.new(test_case, result)
+      end
+
+      def done
+      end
+    end
+
+  end
+end
+

data/lib/cucumber/formatter/fail_fast.rb

@@ -0,0 +1,18 @@
+require 'cucumber/formatter/io'
+require 'cucumber/formatter/console'
+
+module Cucumber
+  module Formatter
+
+    class FailFast
+
+      def initialize(configuration)
+        configuration.on_event :after_test_case do |event|
+          Cucumber.wants_to_quit = true unless event.result.ok?(configuration.strict?)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/formatter/html.rb

@@ -20,7 +20,7 @@ module Cucumber
       include Io
 
       def initialize(runtime, path_or_io, options)
-        @io = ensure_io(path_or_io, "html")
+        @io = ensure_io(path_or_io)
         @runtime = runtime
         @options = options
         @buffer = {}

data/lib/cucumber/formatter/io.rb

@@ -1,7 +1,9 @@
 module Cucumber
   module Formatter
     module Io
-      def ensure_io(path_or_io, name)
+      module_function
+
+      def ensure_io(path_or_io)
         return nil if path_or_io.nil?
         return path_or_io if path_or_io.respond_to?(:write)
         file = File.open(path_or_io, Cucumber.file_mode('w'))

data/lib/cucumber/formatter/json.rb

@@ -11,7 +11,7 @@ module Cucumber
 
       def initialize(runtime, io, _options)
         @runtime = runtime
-        @io = ensure_io(io, 'json')
+        @io = ensure_io(io)
         @feature_hashes = []
       end
 
@@ -29,6 +29,7 @@ module Cucumber
           feature_elements << @test_case_hash
           @element_hash = @test_case_hash
         end
+        @any_step_failed = false
       end
 
       def before_test_step(test_step)
@@ -51,6 +52,11 @@ module Cucumber
       def after_test_step(test_step, result)
         return if internal_hook?(test_step)
         add_match_and_result(test_step, result)
+        @any_step_failed = true if result.failed?
+      end
+
+      def after_test_case(test_case, result)
+        add_failed_around_hook(result) if result.failed? && !@any_step_failed
       end
 
       def done
@@ -123,6 +129,10 @@ module Cucumber
         @element_hash[:after] ||= []
       end
 
+      def around_hooks
+        @element_hash[:around] ||= []
+      end
+
       def after_step_hooks
         @step_hash[:after] ||= []
       end
@@ -159,6 +169,14 @@ module Cucumber
         @step_or_hook_hash[:result] = create_result_hash(result)
       end
 
+      def add_failed_around_hook(result)
+        @step_or_hook_hash = {}
+        around_hooks << @step_or_hook_hash
+        @step_or_hook_hash[:match] = { location: "unknown_hook_location:1" }
+
+        @step_or_hook_hash[:result] = create_result_hash(result)
+      end
+
       def create_match_hash(test_step, result)
         { location: test_step.action_location }
       end

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

@@ -207,9 +207,10 @@ module Cucumber
 
           def before
             formatter.before_feature(node)
-            Ast::Comments.new(node.comments).accept(formatter)
+            language_comment = node.language.iso_code != 'en' ? ["# language: #{node.language.iso_code}"] : []
+            Ast::Comments.new(language_comment + node.comments).accept(formatter)
             Ast::Tags.new(node.tags).accept(formatter)
-            formatter.feature_name node.keyword, indented(node.legacy_conflated_name_and_description)
+            formatter.feature_name node.keyword, node.legacy_conflated_name_and_description
             @delayed_messages = []
             @delayed_embeddings = []
             self
@@ -413,15 +414,6 @@ module Cucumber
             to.class.name == ScenarioOutlinePrinter.name
           end
 
-          def indented(nasty_old_conflation_of_name_and_description)
-            indent = ""
-            nasty_old_conflation_of_name_and_description.split("\n").map do |l|
-              s = "#{indent}#{l}"
-              indent = "  "
-              s
-            end.join("\n")
-          end
-
         end
 
         module PrintsAfterHooks
@@ -749,9 +741,9 @@ module Cucumber
               max_width.result
             end
 
-            require 'gherkin/formatter/escaping'
+            require 'cucumber/gherkin/formatter/escaping'
             FindMaxWidth = Struct.new(:index) do
-              include ::Gherkin::Formatter::Escaping
+              include ::Cucumber::Gherkin::Formatter::Escaping
 
               def examples_table(table, &descend)
                 @result = char_length_of(table.header.values[index])