cucumber 1.3.10 → 2.0.0

data/lib/cucumber/formatter/unicode.rb

@@ -2,11 +2,8 @@
 # Tips for improvement - esp. ruby 1.9: http://www.ruby-forum.com/topic/184730
 require 'cucumber/platform'
 require 'cucumber/formatter/ansicolor'
-$KCODE='u' if Cucumber::RUBY_1_8_7
 
 if Cucumber::WINDOWS
-  require 'iconv' if Cucumber::RUBY_1_8_7
-
   if ENV['CUCUMBER_OUTPUT_ENCODING']
     Cucumber::CODEPAGE = ENV['CUCUMBER_OUTPUT_ENCODING']
   elsif `cmd /c chcp` =~ /(\d+)/
@@ -22,27 +19,17 @@ if Cucumber::WINDOWS
   end
 
   module Cucumber
-    module WindowsOutput #:nodoc:
+    # @private
+    module WindowsOutput
       def self.extended(o)
         o.instance_eval do
+
           def cucumber_preprocess_output(*a)
-            if Cucumber::RUBY_1_8_7
-              begin
-                Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s})
-              rescue Iconv::InvalidEncoding => e
-                STDERR.cucumber_puts("WARNING: #{e.message}")
-                a
-              rescue Iconv::IllegalSequence => e
-                STDERR.cucumber_puts("WARNING: #{e.message}")
-                a
-              end
-            else
-              begin
-                a.map{|arg| arg.to_s.encode(Encoding.default_external)}
-              rescue Encoding::UndefinedConversionError => e
-                STDERR.cucumber_puts("WARNING: #{e.message}")
-                a
-              end
+            begin
+              a.map{|arg| arg.to_s.encode(Encoding.default_external)}
+            rescue Encoding::UndefinedConversionError => e
+              STDERR.cucumber_puts("WARNING: #{e.message}")
+              a
             end
           end
 

data/lib/cucumber/formatter/usage.rb

@@ -114,13 +114,19 @@ module Cucumber
             key.status = :skipped
             key.mean_duration = 0
           else
-            key.status = Ast::StepInvocation.worst_status(steps.map{|step| step[:status]})
+            key.status = worst_status(steps.map{ |step| step[:status] })
             total_duration = steps.inject(0) {|sum, step| step[:duration] + sum}
             key.mean_duration = total_duration / steps.length
           end
         end
       end
 
+      def worst_status(statuses)
+        [:passed, :undefined, :pending, :skipped, :failed].find do |status|
+          statuses.include?(status)
+        end
+      end
+
       def add_unused_stepdefs
         @runtime.unmatched_step_definitions.each do |step_definition|
           stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)

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, false)
-        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/{ast/table.rb → multiline_argument/data_table.rb}

@@ -1,9 +1,9 @@
-require 'gherkin/rubify'
-require 'gherkin/lexer/i18n_lexer'
+require 'forwardable'
 require 'gherkin/formatter/escaping'
+require 'cucumber/core/ast/describes_itself'
 
 module Cucumber
-  module Ast
+  module MultilineArgument
     # Step Definitions that match a plain text Step with a multiline argument table
     # will receive it as an instance of Table. A Table object holds the data of a
     # table parsed from a feature file and lets you access and manipulate the data
@@ -23,13 +23,10 @@ module Cucumber
     #
     # This will store <tt>[['a', 'b'], ['c', 'd']]</tt> in the <tt>data</tt> variable.
     #
-    class Table
+    class DataTable
       class Different < StandardError
-        attr_reader :table
-
         def initialize(table)
-          super('Tables were not identical')
-          @table = table
+          super("Tables were not identical:\n#{table}")
         end
       end
 
@@ -49,38 +46,62 @@ module Cucumber
       end
 
       include Enumerable
-      include Gherkin::Rubify
+      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.
-      #
-      def initialize(raw, conversion_procs = NULL_CONVERSIONS.dup, header_mappings = {}, header_conversion_proc = nil)
-        @cells_class = Cells
-        @cell_class = Cell
-        raw = ensure_array_of_array(rubify(raw))
+
+      # @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)
+        raise ArgumentError, "data must be a Core::Ast::DataTable" unless data.kind_of? Core::Ast::DataTable
+        ast_table = data
         # Verify that it's square
-        raw.transpose
-        create_cell_matrix(raw)
+        ast_table.transpose
+        @cell_matrix = create_cell_matrix(ast_table)
         @conversion_procs = conversion_procs
         @header_mappings = header_mappings
         @header_conversion_proc = header_conversion_proc
+        @ast_table = ast_table
+      end
+
+      def append_to(array)
+        array << self
       end
 
       def to_step_definition_arg
@@ -91,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:
@@ -106,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
@@ -177,14 +198,6 @@ module Cucumber
         cells_rows.each(&proc)
       end
 
-      def accept(visitor) #:nodoc:
-        return if Cucumber.wants_to_quit
-        cells_rows.each do |row|
-          visitor.visit_table_row(row)
-        end
-        nil
-      end
-
       # Matches +pattern+ against the header row of the table.
       # This is used especially for argument transforms.
       #
@@ -200,11 +213,6 @@ module Cucumber
         pattern.match(header_to_match)
       end
 
-      # For testing only
-      def to_sexp #:nodoc:
-        [:table, *cells_rows.map{|row| row.to_sexp}]
-      end
-
       # Redefines the table headers. This makes it possible to use
       # prettier and more flexible header names in the features.  The
       # keys of +mappings+ are Strings or regular expressions
@@ -246,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
@@ -271,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
@@ -409,28 +417,13 @@ module Cucumber
         raise %{The table must have exactly #{width} columns} unless raw[0].size == width
       end
 
-      def arguments_replaced(arguments) #:nodoc:
-        raw_with_replaced_args = raw.map do |row|
-          row.map do |cell|
-            cell_with_replaced_args = cell
-            arguments.each do |name, value|
-              if cell_with_replaced_args && cell_with_replaced_args.include?(name)
-                cell_with_replaced_args = value ? cell_with_replaced_args.gsub(name, value) : nil
-              end
-            end
-            cell_with_replaced_args
-          end
-        end
-        Table.new(raw_with_replaced_args)
-      end
-
       def has_text?(text) #:nodoc:
         raw.flatten.compact.detect{|cell_value| cell_value.index(text)}
       end
 
       def cells_rows #:nodoc:
         @rows ||= cell_matrix.map do |cell_row|
-          @cells_class.new(self, cell_row)
+          Cells.new(self, cell_row)
         end
       end
 
@@ -451,7 +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/formatter/legacy_api/adapter'
         options = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge(options)
         io = StringIO.new
 
@@ -459,14 +454,27 @@ module Cucumber
         Cucumber::Term::ANSIColor.coloring = options[:color]
         formatter = Formatter::Pretty.new(nil, io, options)
         formatter.instance_variable_set('@indent', options[:indent])
-        TreeWalker.new(nil, [formatter]).visit_multiline_arg(self)
-
+        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 description_for_visitors
+        :legacy_table
+      end
+
+      def columns #:nodoc:
+        @columns ||= cell_matrix.transpose.map do |cell_row|
+          Cells.new(self, cell_row)
+        end
+      end
+
+      def to_json(*args)
+        raw.to_json(*args)
+      end
+
       private
 
       TO_S_PREFIXES = Hash.new('    ')
@@ -493,11 +501,11 @@ module Cucumber
         end
       end
 
-      def create_cell_matrix(raw) #:nodoc:
-        @cell_matrix = raw.map do |raw_row|
+      def create_cell_matrix(ast_table) #:nodoc:
+        ast_table.raw.map do |raw_row|
           line = raw_row.line rescue -1
           raw_row.map do |raw_cell|
-            new_cell(raw_cell, line)
+            Cell.new(raw_cell, self, line)
           end
         end
       end
@@ -548,16 +556,6 @@ module Cucumber
         @hashes = @rows_hash = @col_names = @rows = @columns = nil
       end
 
-      def columns #:nodoc:
-        @columns ||= cell_matrix.transpose.map do |cell_row|
-          @cells_class.new(self, cell_row)
-        end
-      end
-
-      def new_cell(raw_cell, line) #:nodoc:
-        @cell_class.new(raw_cell, self, line)
-      end
-
       # Pads our own cell_matrix and returns a cell matrix of same
       # column width that can be used for diffing
       def pad!(other_cell_matrix) #:nodoc:
@@ -599,8 +597,8 @@ module Cucumber
       end
 
       def ensure_table(table_or_array) #:nodoc:
-        return table_or_array if Table === table_or_array
-        Table.new(table_or_array)
+        return table_or_array if DataTable === table_or_array
+        DataTable.from(table_or_array)
       end
 
       def ensure_array_of_array(array)
@@ -670,6 +668,10 @@ module Cucumber
           "row_#{line}"
         end
 
+        def each(&proc)
+          @cells.each(&proc)
+        end
+
         private
 
         def index
@@ -679,10 +681,6 @@ module Cucumber
         def width
           map{|cell| cell.value ? escape_cell(cell.value.to_s).unpack('U*').length : 0}.max
         end
-
-        def each(&proc)
-          @cells.each(&proc)
-        end
       end
 
       class Cell #:nodoc:
@@ -693,11 +691,6 @@ module Cucumber
           @value, @table, @line = value, table, line
         end
 
-        def accept(visitor)
-          return if Cucumber.wants_to_quit
-          visitor.visit_table_cell_value(value, status)
-        end
-
         def inspect!
           @value = "(i) #{value.inspect}"
         end

data/lib/cucumber/multiline_argument/doc_string.rb

@@ -0,0 +1,10 @@
+module Cucumber
+  module MultilineArgument
+    class DocString < SimpleDelegator
+      def append_to(array)
+        array << self
+      end
+    end
+  end
+end
+

data/lib/cucumber/multiline_argument.rb

@@ -0,0 +1,74 @@
+require 'delegate'
+require 'cucumber/multiline_argument/data_table'
+require 'cucumber/multiline_argument/doc_string'
+require 'gherkin/rubify'
+
+module Cucumber
+  module MultilineArgument
+    extend Gherkin::Rubify
+
+    class << self
+      def from_core(node)
+        builder.wrap(node)
+      end
+
+      def from(argument, location=nil)
+        location ||= Core::Ast::Location.of_caller
+        argument = rubify(argument)
+        case argument
+        when String
+          doc_string(argument, 'text/plain', location)
+        when Array
+          location = location.on_line(argument.first.line..argument.last.line)
+          data_table(argument.map{ |row| row.cells }, location)
+        when DataTable, DocString, None
+          argument
+        when nil
+          None.new
+        else
+          raise ArgumentError, "Don't know how to convert #{argument.class} #{argument.inspect} into a MultilineArgument"
+        end
+      end
+
+      def doc_string(argument, content_type, location)
+        builder.doc_string(Core::Ast::DocString.new(argument, content_type, location))
+      end
+
+      def data_table(data, location)
+        builder.data_table(Core::Ast::DataTable.new(data, location))
+      end
+
+      private
+
+      def builder
+        @builder ||= Builder.new
+      end
+
+      class Builder
+        def wrap(node)
+          @result = None.new
+          node.describe_to(self)
+          @result
+        end
+
+        def doc_string(node, *args)
+          @result = DocString.new(node)
+        end
+
+        def data_table(node, *args)
+          @result = DataTable.new(node)
+        end
+      end
+    end
+
+    class None
+      def append_to(array)
+      end
+
+      def describe_to(visitor)
+      end
+    end
+  end
+end
+
+require 'cucumber/ast'

data/lib/cucumber/platform.rb

@@ -3,28 +3,29 @@
 require 'rbconfig'
 
 module Cucumber
-unless defined?(Cucumber::VERSION)
-  VERSION       = '1.3.10'
-  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
-  RAILS         = defined?(Rails)
-  RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
-  RUBY_2_0      = RUBY_VERSION =~ /^2\.0/
-  RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
-  RUBY_1_8_7    = RUBY_VERSION =~ /^1\.8\.7/
+  unless defined?(Cucumber::VERSION)
+    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)
+    WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+    OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
+    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/
 
-  class << self
-    attr_accessor :use_full_backtrace
+    class << self
+      attr_accessor :use_full_backtrace
 
-    def file_mode(m, encoding="UTF-8") #:nodoc:
-      RUBY_1_8_7 ? m : "#{m}:#{encoding}"
+      # @private
+      def file_mode(m, encoding="UTF-8")
+        "#{m}:#{encoding}"
+      end
     end
+    self.use_full_backtrace = false
   end
-  self.use_full_backtrace = false
-end
 end