cucumber 2.0.0.rc.4 → 2.0.0.rc.5

data/lib/cucumber/encoding.rb

@@ -0,0 +1,5 @@
+# See https://github.com/cucumber/cucumber/issues/693
+if defined? Encoding
+  Encoding.default_external = 'utf-8'
+  Encoding.default_internal = 'utf-8'
+end

data/lib/cucumber/errors.rb

@@ -20,6 +20,14 @@ module Cucumber
     end
   end
 
+  # Raised when there is no matching StepDefinition for a step called
+  # from within another step definition.
+  class UndefinedDynamicStep < StandardError
+    def initialize(step_name)
+      super %(Undefined dynamic step: "#{step_name}")
+    end
+  end
+
   # Raised when a StepDefinition's block invokes World#pending
   class Pending < Core::Test::Result::Pending
   end

data/lib/cucumber/filters/prepare_world.rb

@@ -1,5 +1,5 @@
 require 'cucumber/core/filter'
-require 'cucumber/ast/facade'
+require 'cucumber/running_test_case'
 require 'cucumber/hooks'
 
 module Cucumber
@@ -17,17 +17,25 @@ module Cucumber
         end
 
         def test_case
-          init_scenario = Cucumber::Hooks.before_hook(@original_test_case.source) do
+          init_scenario = Cucumber::Hooks.around_hook(@original_test_case.source) do |continue|
             @runtime.begin_scenario(scenario)
+            continue.call
+            @runtime.end_scenario(scenario)
           end
-          steps = [init_scenario] + @original_test_case.test_steps
-          @original_test_case.with_steps(steps)
+          around_hooks = [init_scenario] + @original_test_case.around_hooks
+
+          default_hook = Cucumber::Hooks.before_hook(@original_test_case.source) do
+            #no op - legacy format adapter expects a before hooks
+          end
+          steps = [default_hook] + @original_test_case.test_steps
+
+          @original_test_case.with_around_hooks(around_hooks).with_steps(steps)
         end
 
         private
 
         def scenario
-          @scenario ||= Ast::Facade.new(test_case).build_scenario
+          @scenario ||= RunningTestCase.new(test_case)
         end
       end
 

data/lib/cucumber/formatter/console.rb

@@ -118,7 +118,7 @@ module Cucumber
       end
 
       def print_exception(e, status, indent)
-        message = "#{e.message} (#{e.class})"
+        message = "#{e.message} (#{e.class})".force_encoding("UTF-8")
         if ENV['CUCUMBER_TRUNCATE_OUTPUT']
           message = linebreaks(message, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
         end

data/lib/cucumber/formatter/gherkin_formatter_adapter.rb

@@ -21,12 +21,10 @@ module Cucumber
 
       def before_background(background)
         @outline = false
-        @before_steps = true
         @gf.background(background.gherkin_statement)
       end
 
       def before_feature_element(feature_element)
-        @before_steps = true
         case(feature_element)
         when Core::Ast::Scenario
           @outline = false
@@ -44,6 +42,10 @@ module Cucumber
         end
       end
 
+      def before_test_case(test_case)
+        @delay_output = true
+      end
+
       def scenario_name(keyword, name, file_colon_line, source_indent)
         if @outline and @options[:expand]
           return if not @in_instantiated_scenario
@@ -70,10 +72,11 @@ module Cucumber
         unless @outline and @options[:expand]
           @gf.step(step.gherkin_statement)
           pass_delayed_output
-          @before_steps = false
+          @delay_output = false
         else 
           if @in_instantiated_scenario
             @current_step_hash = to_hash(step.gherkin_statement)
+            @delay_output = true
           end
         end
         if @print_empty_match
@@ -120,7 +123,7 @@ module Cucumber
               @current_step_hash['rows'],
               @current_step_hash['doc_string']))
           pass_delayed_output
-          @before_steps = false
+          @delay_output = false
           @gf.match(@current_match)
           @gf.result(@current_result)
         end
@@ -165,7 +168,7 @@ module Cucumber
         if defined?(JRUBY_VERSION)
           data = data.to_java_bytes
         end
-        unless @before_steps
+        unless @delay_output
           @gf.embedding(mime_type, data)
         else
           @delayed_embeddings.push [mime_type, data]
@@ -173,7 +176,7 @@ module Cucumber
       end
 
       def puts(message)
-        unless @before_steps
+        unless @delay_output
           @gf.write(message)
         else
           @delayed_messages.push message

data/lib/cucumber/formatter/junit.rb

@@ -129,6 +129,34 @@ module Cucumber
         @header_row = false if @header_row
       end
 
+      def before_test_case(test_case)
+        if @options[:expand] and test_case.keyword == "Scenario Outline"
+          @exception = nil
+        end
+      end
+
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+        if @options[:expand] and @in_examples
+          if not @exception and exception
+            @exception = exception
+          end
+        end
+      end
+
+      def after_test_case(test_case, result)
+        if @options[:expand] and test_case.keyword == "Scenario Outline"
+          test_case_name = NameBuilder.new(test_case)
+          @scenario = test_case_name.outline_name
+          @output = "#{test_case.keyword}: #{@scenario}\n\n"
+          if result.failed?
+            @output += "Example row: #{test_case_name.row_name}\n"
+            @output += "\nMessage:\n"
+          end
+          test_case_result = ResultBuilder.new(result)
+          build_testcase(test_case_result.test_case_duration, test_case_result.status, @exception, test_case_name.name_suffix)
+        end
+      end
+
       private
 
       def build_testcase(duration, status, exception = nil, suffix = "")
@@ -176,5 +204,72 @@ module Cucumber
       end
       
     end
+
+    class NameBuilder
+      attr_reader :outline_name, :name_suffix, :row_name
+
+      def initialize(test_case)
+        test_case.describe_source_to self
+      end
+
+      def feature(*)
+        self
+      end
+
+      def scenario(*)
+        self
+      end
+
+      def scenario_outline(outline)
+        @outline_name = outline.name
+        self
+      end
+
+      def examples_table(*)
+        self
+      end
+
+      def examples_table_row(row)
+        @row_name = '| ' + row.values.join(' | ') + ' |'
+        @name_suffix = " (outline example : #{@row_name})"
+        self
+      end
+    end
+
+    class ResultBuilder
+      attr_reader :status, :test_case_duration
+      def initialize(result)
+        @test_case_duration = 0
+        result.describe_to(self)
+      end
+
+      def passed
+        @status = :passed
+      end
+
+      def failed
+        @status = :failed
+      end
+
+      def undefined
+        @status = :undefined
+      end
+
+      def skipped
+        @status = :skipped
+      end
+
+      def pending(*)
+        @status = :pending
+      end
+
+      def exception(*)
+      end
+
+      def duration(duration, *)
+        duration.tap { |duration| @test_case_duration = duration.nanoseconds / 10 ** 9.0 }
+      end
+    end
+
   end
 end

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

@@ -126,6 +126,30 @@ module Cucumber
           end
         end
 
+        module TestCaseSource
+          def self.for(test_case, result)
+            collector = Collector.new
+            test_case.describe_source_to collector, result
+            collector.result.freeze
+          end
+
+          class Collector
+            attr_reader :result
+
+            def initialize
+              @result = CaseSource.new
+            end
+
+            def method_missing(name, node, test_case_result, *args)
+              result.send "#{name}=", node
+            end
+          end
+
+          require 'ostruct'
+          class CaseSource < OpenStruct
+          end
+        end
+
         module TestStepSource
           def self.for(test_step, result)
             collector = Collector.new
@@ -194,6 +218,7 @@ module Cucumber
 
           def before_test_case(test_case)
             @before_hook_results = Ast::HookResultCollection.new
+            @test_step_results = []
           end
 
           def before_test_step(test_step)
@@ -204,13 +229,20 @@ module Cucumber
             # TODO: stop calling self, and describe source to another object
             test_step.describe_source_to(self, result)
             print_step
+            @test_step_results << result
           end
 
-          def after_test_case(*args)
+          def after_test_case(test_case, test_case_result)
             if current_test_step_source && current_test_step_source.step_result.nil?
               switch_step_container
             end
 
+            if test_case_result.failed? && !any_test_steps_failed?
+              # around hook must have failed. Print the error.
+              switch_step_container(TestCaseSource.for(test_case, test_case_result))
+              LegacyResultBuilder.new(test_case_result).describe_exception_to formatter
+            end
+
             # messages and embedding should already have been handled, but just in case...
             @delayed_messages.each { |message| formatter.puts(message) }
             @delayed_embeddings.each { |embedding| embedding.send_to_formatter(formatter) }
@@ -276,8 +308,12 @@ module Cucumber
           attr_reader :before_hook_results
           private :before_hook_results
 
-          def switch_step_container
-            switch_to_child select_step_container(current_test_step_source), current_test_step_source
+          def any_test_steps_failed?
+            @test_step_results.any? &:failed?
+          end
+
+          def switch_step_container(source = current_test_step_source)
+            switch_to_child select_step_container(source), source
           end
 
           def select_step_container(source)

data/lib/cucumber/platform.rb

@@ -4,7 +4,7 @@ require 'rbconfig'
 
 module Cucumber
   unless defined?(Cucumber::VERSION)
-    VERSION       = '2.0.0.rc.4'
+    VERSION       = '2.0.0.rc.5'
     BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
     LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
     JRUBY         = defined?(JRUBY_VERSION)

data/lib/cucumber/project_initializer.rb

@@ -0,0 +1,43 @@
+module Cucumber
+
+  # Generates generic file structure for a cucumber project
+  class ProjectInitializer
+    def run
+      create_directory('features')
+      create_directory('features/step_definitions')
+      create_directory('features/support')
+      create_file('features/support/env.rb')
+    end
+
+    private
+
+    def create_directory(dir_name)
+      create_directory_or_file dir_name, true
+    end
+
+    def create_file(file_name)
+      create_directory_or_file file_name, false
+    end
+
+    def create_directory_or_file(file_name, directory)
+      file_type = if directory
+                    :mkdir_p
+                  else
+                    :touch
+                  end
+
+      report_exists(file_name) || return if File.exists?(file_name)
+
+      report_creating(file_name)
+      FileUtils.send file_type, file_name
+    end
+
+    def report_exists(file)
+      puts "   exist   #{file}"
+    end
+
+    def report_creating(file)
+      puts "  create   #{file}"
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -44,10 +44,19 @@ module Cucumber
           raise ArgumentError unless proc_or_sym.is_a?(Symbol)
           message = proc_or_sym
           target_proc = parse_target_proc_from(options)
-          lambda do |*args|
+          patch_location_onto lambda { |*args|
             target = instance_exec(&target_proc)
             target.send(message, *args)
-          end
+          }
+        end
+
+        def patch_location_onto(block)
+          file, line = caller[5].split(':')[0..1]
+          location = Core::Ast::Location.new(
+            Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd)),
+            line)
+          block.define_singleton_method(:file_colon_line) { location.to_s }
+          block
         end
 
         def parse_target_proc_from(options)

data/lib/cucumber/rb_support/rb_world.rb

@@ -37,7 +37,7 @@ module Cucumber
       # @param [String,Cucumber::Ast::DocString,Cucumber::Ast::Table] multiline_argument
       def step(name, raw_multiline_arg=nil)
         location = Core::Ast::Location.of_caller
-        @__cucumber_runtime.invoke(name, MultilineArgument.from(raw_multiline_arg, location))
+        @__cucumber_runtime.invoke_dynamic_step(name, MultilineArgument.from(raw_multiline_arg, location))
       end
 
       # Run a snippet of Gherkin
@@ -48,7 +48,7 @@ module Cucumber
       #   }
       # @param [String] steps_text The Gherkin snippet to run
       def steps(steps_text)
-        @__cucumber_runtime.invoke_steps(steps_text, @__natural_language, caller[0])
+        @__cucumber_runtime.invoke_dynamic_steps(steps_text, @__natural_language, caller[0])
       end
 
       # Parse Gherkin into a {Cucumber::Ast::Table} object.

data/lib/cucumber/rb_support/snippet.rb

@@ -2,7 +2,7 @@ module Cucumber
   module RbSupport
     module Snippet
 
-      ARGUMENT_PATTERNS = ['"(.*?)"', '(\d+)']
+      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
 
       class BaseSnippet
 

data/lib/cucumber/rspec/doubles.rb

@@ -3,7 +3,7 @@ require 'rspec/mocks'
 World(RSpec::Mocks::ExampleMethods)
 
 Before do
-  if RSpec::Mocks::Version::STRING.split('.').first.to_i > 2
+  if RSpec::Mocks::Version::STRING >= "2.9.9"
     RSpec::Mocks.setup
   else
     RSpec::Mocks.setup(self)

data/lib/cucumber/running_test_case.rb

@@ -0,0 +1,115 @@
+require 'delegate'
+
+module Cucumber
+  # Represents the current status of a running test case.
+  # 
+  # This wraps a `Cucumber::Core::Test::Case` and delegates
+  # many methods to that object.
+  #
+  # We decorete the core object with the current result.
+  # In the first Before hook of a scenario, this will be an
+  # instance of `Cucumber::Core::Test::Result::Unknown`
+  # but as the scenario runs, it will be updated to reflect
+  # the passed / failed / undefined / skipped status of
+  # the test case.
+  #
+  # The test case might come from a regular Scenario or
+  # a Scenario outline. You can call the `#outline?`
+  # predicate to find out. If it's from an outline, 
+  # you get a couple of extra methods.
+  module RunningTestCase
+    def self.new(test_case)
+      Builder.new(test_case).result
+    end
+
+    class Builder
+      def initialize(test_case)
+        @test_case = test_case
+        test_case.describe_source_to(self)
+      end
+
+      def feature(feature)
+      end
+
+      def scenario(scenario)
+        @factory = Scenario
+      end
+
+      def scenario_outline(scenario)
+        @factory = ScenarioOutlineExample
+      end
+
+      def examples_table(examples_table)
+      end
+
+      def examples_table_row(row)
+      end
+
+      def result
+        @factory.new(@test_case)
+      end
+    end
+    private_constant :Builder
+
+    class Scenario < SimpleDelegator
+      def initialize(test_case, result = Core::Test::Result::Unknown.new)
+        @test_case = test_case
+        @result = result
+        super test_case
+      end
+
+      def accept_hook?(hook)
+        hook.tag_expressions.all? { |expression| @test_case.match_tags?(expression) }
+      end
+
+      def failed?
+        @result.failed?
+      end
+
+      def passed?
+        !failed?
+      end
+
+      def title
+        warn("deprecated: call #name instead")
+        name
+      end
+
+      def source_tags
+        #warn('deprecated: call #tags instead')
+        tags
+      end
+
+      def source_tag_names
+        tags.map &:name
+      end
+
+      def skip_invoke!
+        Cucumber.deprecate(self.class.name, __method__, "Call #skip_this_scenario on the World directly")
+        raise Cucumber::Core::Test::Result::Skipped
+      end
+
+      def outline?
+        false
+      end
+
+      def with_result(result)
+        self.class.new(@test_case, result)
+      end
+    end
+
+    class ScenarioOutlineExample < Scenario
+      def outline?
+        true
+      end
+
+      def scenario_outline
+        self
+      end
+
+      def cell_values
+        source.last.values
+      end
+    end
+  end
+end