cucumber 2.0.0.beta.3 → 2.0.0

data/lib/cucumber/hooks.rb

@@ -0,0 +1,97 @@
+require 'cucumber/core/test/around_hook'
+
+module Cucumber
+
+  # Hooks quack enough like `Cucumber::Core::Ast` source nodes that we can use them as 
+  # source for test steps
+  module Hooks
+
+    class << self
+      def before_hook(source, &block)
+        build_hook_step(source, block, BeforeHook, Core::Test::UnskippableAction)
+      end
+
+      def after_hook(source, &block)
+        build_hook_step(source, block, AfterHook, Core::Test::UnskippableAction)
+      end
+
+      def after_step_hook(source, &block)
+        raise ArgumentError unless source.last.kind_of?(Core::Ast::Step)
+        build_hook_step(source, block, AfterStepHook, Core::Test::Action)
+      end
+
+      def around_hook(source, &block)
+        Core::Test::AroundHook.new(&block)
+      end
+
+      private
+
+      def build_hook_step(source, block, hook_type, action_type)
+        action = action_type.new(&block)
+        hook = hook_type.new(action.location)
+        Core::Test::Step.new(source + [hook], action)
+      end
+    end
+
+    class AfterHook
+      attr_reader :location
+
+      def initialize(location)
+        @location = location
+      end
+
+      def name
+        "After hook"
+      end
+
+      def match_locations?(queried_locations)
+        queried_locations.any? { |other_location| other_location.match?(location) }
+      end
+
+      def describe_to(visitor, *args)
+        visitor.after_hook(self, *args)
+      end
+    end
+
+    class BeforeHook
+      attr_reader :location
+
+      def initialize(location)
+        @location = location
+      end
+
+      def name
+        "Before hook"
+      end
+
+      def match_locations?(queried_locations)
+        queried_locations.any? { |other_location| other_location.match?(location) }
+      end
+
+      def describe_to(visitor, *args)
+        visitor.before_hook(self, *args)
+      end
+    end
+
+    class AfterStepHook
+      attr_reader :location
+
+      def initialize(location)
+        @location = location
+      end
+
+      def name
+        "AfterStep hook"
+      end
+
+      def match_locations?(queried_locations)
+        queried_locations.any? { |other_location| other_location.match?(location) }
+      end
+
+      def describe_to(visitor, *args)
+        visitor.after_step_hook(self, *args)
+      end
+    end
+
+  end
+end

data/lib/cucumber/language_support/language_methods.rb

@@ -4,21 +4,6 @@ require 'cucumber/step_definition_light'
 module Cucumber
   module LanguageSupport
     module LanguageMethods
-      def around(scenario)
-        execute_around(scenario) do
-          yield
-        end
-      end
-
-      def before(scenario)
-        begin_scenario(scenario)
-        execute_before(scenario)
-      end
-
-      def after(scenario)
-        execute_after(scenario)
-        end_scenario
-      end
 
       def after_configuration(configuration)
         hooks[:after_configuration].each do |hook|
@@ -26,12 +11,6 @@ module Cucumber
         end
       end
 
-      def execute_after_step(scenario)
-        hooks_for(:after_step, scenario).each do |hook|
-          invoke(hook, 'AfterStep', scenario)
-        end
-      end
-
       def execute_transforms(args)
         args.map do |arg|
           matching_transform = transforms.detect {|transform| transform.match(arg) }
@@ -87,39 +66,6 @@ module Cucumber
         @transforms ||= []
       end
 
-      def execute_around(scenario, &block)
-        hooks_for(:around, scenario).reverse.inject(block) do |blk, hook|
-          proc do
-            invoke(hook, 'Around', scenario, true) do
-              blk.call(scenario)
-            end
-          end
-        end.call
-      end
-
-      def execute_before(scenario)
-        hooks_for(:before, scenario).each do |hook|
-          invoke(hook, 'Before', scenario, true)
-        end
-      end
-
-      def execute_after(scenario)
-        hooks_for(:after, scenario).reverse_each do |hook|
-          invoke(hook, 'After', scenario, true)
-        end
-      end
-
-      def invoke(hook, location, scenario, exception_fails_scenario, &block)
-        begin
-          hook.invoke(location, scenario, &block)
-        rescue Exception => exception
-          if exception_fails_scenario
-            scenario.fail!(exception)
-          else
-            raise
-          end
-        end
-      end
     end
   end
 end

data/lib/cucumber/multiline_argument/data_table.rb

@@ -1,3 +1,4 @@
+require 'forwardable'
 require 'gherkin/formatter/escaping'
 require 'cucumber/core/ast/describes_itself'
 
@@ -46,34 +47,50 @@ module Cucumber
 
       include Enumerable
       include Core::Ast::DescribesItself
+      extend Forwardable
 
       NULL_CONVERSIONS = Hash.new({ :strict => false, :proc => lambda{ |cell_value| cell_value } }).freeze
 
       attr_accessor :file
+      def_delegator :@ast_table, :location
 
       def self.default_arg_name #:nodoc:
         "table"
       end
 
-      def self.parse(text, uri, offset)
-        builder = Builder.new
-        lexer = Gherkin::Lexer::I18nLexer.new(builder)
-        lexer.scan(text)
-        new(builder.rows)
+      class << self
+        def from(data, location = Core::Ast::Location.of_caller)
+          case data
+          when Array
+            from_array(data, location)
+          when String
+            parse(data, location)
+          else
+            raise ArgumentError, "expected data to be a String or an Array."
+          end
+        end
+
+        private
+        def parse(text, location = Core::Ast::Location.of_caller)
+          builder = Builder.new
+          lexer = Gherkin::Lexer::I18nLexer.new(builder)
+          lexer.scan(text)
+          from_array(builder.rows, location)
+        end
+
+        def from_array(data, location = Core::Ast::Location.of_caller)
+          new Core::Ast::DataTable.new(data, location)
+        end
       end
 
-      # Creates a new instance. +raw+ should be an Array of Array of String
-      # or an Array of Hash (similar to what #hashes returns).
-      # You don't typically create your own Table objects - Cucumber will do
-      # it internally and pass them to your Step Definitions.
-      #
+
+      # @param data [Core::Ast::DataTable] the data for the table
+      # @param conversion_procs [Hash] see map_columns!
+      # @param header_mappings [Hash] see map_headers!
+      # @param header_conversion_proc [Proc] see map_headers!
       def initialize(data, conversion_procs = NULL_CONVERSIONS.dup, header_mappings = {}, header_conversion_proc = nil)
-        ast_table = case data
-                    when Core::Ast::DataTable
-                      data
-                    when Array
-                      Core::Ast::DataTable.new(data, Core::Ast::Location.of_caller)
-                    end
+        raise ArgumentError, "data must be a Core::Ast::DataTable" unless data.kind_of? Core::Ast::DataTable
+        ast_table = data
         # Verify that it's square
         ast_table.transpose
         @cell_matrix = create_cell_matrix(ast_table)
@@ -95,7 +112,7 @@ module Cucumber
       # registered with #map_column! and #map_headers!.
       #
       def dup
-        self.class.new(raw.dup, @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
+        self.class.new(Core::Ast::DataTable.new(raw, location), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Returns a new, transposed table. Example:
@@ -110,7 +127,7 @@ module Cucumber
       #   | 4 | 2 |
       #
       def transpose
-        self.class.new(raw.transpose, @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
+        self.class.new(Core::Ast::DataTable.new(raw.transpose, location), @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Converts this table into an Array of Hash where the keys of each
@@ -237,7 +254,7 @@ module Cucumber
 
       # Returns a new Table where the headers are redefined. See #map_headers!
       def map_headers(mappings={}, &block)
-        self.class.new raw.dup, @conversion_procs.dup, mappings, block
+        self.class.new(Core::Ast::DataTable.new(raw, location), @conversion_procs.dup, mappings, block)
       end
 
       # Change how #hashes converts column values. The +column_name+ argument identifies the column
@@ -262,7 +279,7 @@ module Cucumber
       def map_column(column_name, strict=true, &conversion_proc)
         conversion_procs = @conversion_procs.dup
         conversion_procs[column_name.to_s] = { :strict => strict, :proc => conversion_proc }
-        self.class.new(raw.dup, conversion_procs, @header_mappings.dup, @header_conversion_proc)
+        self.class.new(Core::Ast::DataTable.new(raw, location), conversion_procs, @header_mappings.dup, @header_conversion_proc)
       end
 
       # Compares +other_table+ to self. If +other_table+ contains columns
@@ -427,8 +444,9 @@ module Cucumber
       end
 
       def to_s(options = {}) #:nodoc:
+        # TODO: factor out this code so we don't depend on such a big lump of old cruft
         require 'cucumber/formatter/pretty'
-        require 'cucumber/reports/legacy_formatter'
+        require 'cucumber/formatter/legacy_api/adapter'
         options = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge(options)
         io = StringIO.new
 
@@ -436,19 +454,13 @@ module Cucumber
         Cucumber::Term::ANSIColor.coloring = options[:color]
         formatter = Formatter::Pretty.new(nil, io, options)
         formatter.instance_variable_set('@indent', options[:indent])
-
-        Reports::Legacy::Ast::MultilineArg.for(self).accept(Reports::FormatterWrapper.new([formatter]))
-
+        Formatter::LegacyApi::Ast::MultilineArg.for(self).accept(Formatter::Fanout.new([formatter]))
         Cucumber::Term::ANSIColor.coloring = c
         io.rewind
         s = "\n" + io.read + (" " * (options[:indent] - 2))
         s
       end
 
-      def location
-        @ast_table.location
-      end
-
       def description_for_visitors
         :legacy_table
       end
@@ -586,7 +598,7 @@ module Cucumber
 
       def ensure_table(table_or_array) #:nodoc:
         return table_or_array if DataTable === table_or_array
-        DataTable.new(table_or_array)
+        DataTable.from(table_or_array)
       end
 
       def ensure_array_of_array(array)

data/lib/cucumber/platform.rb

@@ -4,16 +4,16 @@ require 'rbconfig'
 
 module Cucumber
   unless defined?(Cucumber::VERSION)
-    VERSION       = '2.0.0.beta.3'
+    VERSION       = '2.0.0'
     BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
     LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
     JRUBY         = defined?(JRUBY_VERSION)
-    IRONRUBY      = defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
     WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
     OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
-    WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
+    WINDOWS_MRI   = WINDOWS && !JRUBY
     RAILS         = defined?(Rails)
     RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    RUBY_2_2      = RUBY_VERSION =~ /^2\.2/
     RUBY_2_1      = RUBY_VERSION =~ /^2\.1/
     RUBY_2_0      = RUBY_VERSION =~ /^2\.0/
     RUBY_1_9      = RUBY_VERSION =~ /^1\.9/

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_hook.rb

@@ -10,8 +10,8 @@ module Cucumber
         @proc = proc
       end
 
-      def invoke(location, argument, &block)
-        @rb_language.current_world.cucumber_instance_exec(false, location, *[argument, block].compact, &@proc)
+      def invoke(pseudo_method, arguments, &block)
+        @rb_language.current_world.cucumber_instance_exec(false, pseudo_method, *[arguments, block].compact, &@proc)
       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_transform.rb

@@ -39,7 +39,9 @@ module Cucumber
 
     private
       def convert_captures(regexp_source)
-        regexp_source.gsub(/(\()(?!\?:)/,'(?:')
+        regexp_source
+          .gsub(/(\()(?!\?[<:=!])/,'(?:')
+          .gsub(/(\(\?<)(?![=!])/,'(?:<')
       end
 
       def strip_captures(regexp_source)

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

data/lib/cucumber/runtime/after_hooks.rb

@@ -0,0 +1,24 @@
+module Cucumber
+  class Runtime
+    class AfterHooks
+      def initialize(action_blocks)
+        @action_blocks = action_blocks
+      end
+
+      def apply_to(test_case)
+        test_case.with_steps(
+          test_case.test_steps + after_hooks(test_case.source).reverse
+        )
+      end
+
+      private
+
+      def after_hooks(source)
+        @action_blocks.map do |action_block|
+          Hooks.after_hook(source, &action_block)
+        end
+      end
+    end
+  end
+end
+

data/lib/cucumber/runtime/before_hooks.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  class Runtime
+    class BeforeHooks
+      def initialize(action_blocks)
+        @action_blocks = action_blocks
+      end
+
+      def apply_to(test_case)
+        test_case.with_steps(
+          before_hooks(test_case.source) + test_case.test_steps
+        )
+      end
+
+      private
+
+      def before_hooks(source)
+        @action_blocks.map do |action_block|
+          Hooks.before_hook(source, &action_block)
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/for_programming_languages.rb

@@ -23,8 +23,8 @@ module Cucumber
         :step_match
 
       def_delegators :@support_code,
-        :invoke_steps,
-        :invoke,
+        :invoke_dynamic_steps,
+        :invoke_dynamic_step,
         :load_programming_language
 
       # Returns a Cucumber::MultilineArgument::DataTable for +text_or_table+, which can either
@@ -44,17 +44,13 @@ module Cucumber
       #     %w{ CUC-101 Peeler      22     }
       #   ])
       #
-      def table(text_or_table, file=nil, line_offset=0)
+      def table(text_or_table, file=nil, line=0)
         if !file
           location = Core::Ast::Location.of_caller
         else
           location = Core::Ast::Location.new(file, line)
         end
-        if Array === text_or_table
-          MultilineArgument::DataTable.new(text_or_table, location)
-        else
-          MultilineArgument::DataTable.parse(text_or_table, file, location)
-        end
+        MultilineArgument::DataTable.from(text_or_table, location)
       end
 
       # Returns a Cucumber::MultilineArgument::DocString for +body+.

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