cucumber 1.3.20 → 2.0.0.beta.1

data/lib/cucumber/multiline_argument.rb

@@ -0,0 +1,115 @@
+require 'delegate'
+module Cucumber
+  module MultilineArgument
+    def self.from(core_multiline_arg)
+      Builder.new(core_multiline_arg).result
+    end
+
+    class Builder
+      def initialize(multiline_arg)
+        multiline_arg.describe_to self
+      end
+
+      def doc_string(string, *args)
+        @result = DocString.new(string)
+      end
+
+      def data_table(table, *args)
+        @result = DataTable.new(table)
+      end
+
+      def result
+        @result || None.new
+      end
+    end
+
+    class DocString < SimpleDelegator
+      def append_to(array)
+        array << self
+      end
+    end
+
+    class DataTable < SimpleDelegator
+      def append_to(array)
+        array << self
+      end
+
+      def to_json(options)
+        raw.to_json(options)
+      end
+
+      def diff!(other_table)
+        other_table = ensure_table(other_table)
+        other_table_cell_matrix = other_table.cell_matrix
+
+        ensure_green!
+
+        require_diff_lcs
+        cell_matrix.extend(Diff::LCS)
+
+        changes = cell_matrix.diff(other_table_cell_matrix).flatten
+
+        return if changes.empty?
+
+        inserted = 0
+        missing  = 0
+
+        changes.each do |change|
+          if(change.action == '-')
+            missing_row_pos = change.position + inserted
+            cell_matrix[missing_row_pos].each{|cell| cell.status = :undefined}
+
+            missing += 1
+          else # '+'
+            inserted_row = change.element
+            inserted_row.each{|cell| cell.status = :comment}
+
+            insert_row_pos = change.position + missing
+            cell_matrix.insert(insert_row_pos, inserted_row)
+
+            inserted += 1
+          end
+        end
+
+        raise Different.new(self)
+      end
+
+      def ensure_green! #:nodoc:
+        each_cell{|cell| cell.status = :passed}
+      end
+
+      private
+
+      def ensure_table(table_or_array) #:nodoc:
+        return table_or_array if DataTable === table_or_array
+        DataTable.new(table_or_array)
+      end
+
+      def require_diff_lcs #:nodoc:
+        begin
+          require 'diff/lcs'
+        rescue LoadError => e
+          e.message << "\n Please gem install diff-lcs\n"
+          raise e
+        end
+      end
+
+      class Different < StandardError
+        attr_reader :table
+        def initialize(table)
+          @table = table
+          super("Tables were not identical")
+        end
+      end
+    end
+
+    class None
+      def append_to(array)
+      end
+
+      def describe_to(visitor)
+      end
+    end
+  end
+end
+

data/lib/cucumber/platform.rb

@@ -3,30 +3,29 @@
 require 'rbconfig'
 
 module Cucumber
-unless defined?(Cucumber::VERSION)
-  VERSION       = '1.3.20'
-  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_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/
-  RUBY_1_8_7    = RUBY_VERSION =~ /^1\.8\.7/
+  unless defined?(Cucumber::VERSION)
+    VERSION       = '2.0.0.beta.1'
+    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_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

data/lib/cucumber/rake/task.rb

@@ -23,12 +23,6 @@ module Cucumber
     #     t.cucumber_opts = %w{--format progress}
     #   end
     #
-    # This task can also be configured to be run with RCov:
-    #
-    #   Cucumber::Rake::Task.new do |t|
-    #     t.rcov = true
-    #   end
-    #
     # See the attributes for additional configuration possibilities.
     class Task
       include Gherkin::Formatter::AnsiEscapes
@@ -103,27 +97,6 @@ module Cucumber
         end
       end
 
-      class RCovCucumberRunner < ForkedCucumberRunner #:nodoc:
-
-        def initialize(libs, cucumber_bin, cucumber_opts, bundler, feature_files, rcov_opts)
-          super(       libs, cucumber_bin, cucumber_opts, bundler, feature_files )
-          @rcov_opts = rcov_opts
-        end
-
-        def cmd
-          if use_bundler
-            [Cucumber::RUBY_BINARY, '-S', 'bundle', 'exec', 'rcov', @rcov_opts,
-             quoted_binary(@cucumber_bin), '--', @cucumber_opts, @feature_files].flatten
-          else
-            [Cucumber::RUBY_BINARY, '-I', load_path(@libs), '-S', 'rcov', @rcov_opts,
-             quoted_binary(@cucumber_bin), '--', @cucumber_opts, @feature_files].flatten
-          end
-        end
-
-      end
-
-      LIB = File.expand_path(File.dirname(__FILE__) + '/../..') #:nodoc:
-
       # Directories to add to the Ruby $LOAD_PATH
       attr_accessor :libs
 
@@ -137,23 +110,6 @@ module Cucumber
         @cucumber_opts = String === opts ? opts.split(' ') : opts
       end
 
-      # Run cucumber with RCov? Defaults to false. If you set this to
-      # true, +fork+ is implicit.
-      attr_accessor :rcov
-      def rcov=(flag)
-        if flag && !Cucumber::RUBY_1_8_7
-          raise failed + "RCov only works on Ruby 1.8.x. You may want to use SimpleCov: https://github.com/colszowka/simplecov" + reset
-        end
-        @rcov = flag
-      end
-
-      # Extra options to pass to rcov.
-      # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
-      attr_accessor :rcov_opts
-      def rcov_opts=(opts) #:nodoc:
-        @rcov_opts = String === opts ? opts.split(' ') : opts
-      end
-
       # Whether or not to fork a new ruby interpreter. Defaults to true. You may gain
       # some startup speed if you set it to false, but this may also cause issues with
       # your load path and gems.
@@ -176,12 +132,8 @@ module Cucumber
         @fork = true
         @libs = ['lib']
         @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
-
         yield self if block_given?
-
         @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
-        @libs.insert(0, LIB) if binary == Cucumber::BINARY
-
         define_task
       end
 
@@ -194,13 +146,10 @@ module Cucumber
 
       def runner(task_args = nil) #:nodoc:
         cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
-        if(@rcov)
-          RCovCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files, rcov_opts)
-        elsif(@fork)
-          ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files)
-        else
-          InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
+        if(@fork)
+          return ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files)
         end
+        InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
       end
 
       def cucumber_opts_with_profile #:nodoc:

data/lib/cucumber/rb_support/rb_language.rb

@@ -37,7 +37,6 @@ module Cucumber
 
       Gherkin::I18n.code_keywords.each do |adverb|
         RbDsl.alias_adverb(adverb)
-        RbWorld.alias_adverb(adverb)
       end
 
       def initialize(runtime)
@@ -57,9 +56,9 @@ module Cucumber
         end.compact
       end
 
-      def snippet_text(code_keyword, step_name, multiline_arg_class, snippet_type = :regexp)
+      def snippet_text(code_keyword, step_name, multiline_arg, snippet_type = :regexp)
         snippet_class = typed_snippet_class(snippet_type)
-        snippet_class.new(code_keyword, step_name, multiline_arg_class).to_s
+        snippet_class.new(code_keyword, step_name, multiline_arg).to_s
       end
 
       def begin_rb_scenario(scenario)
@@ -95,8 +94,6 @@ module Cucumber
         load File.expand_path(code_file) # This will cause self.add_step_definition, self.add_hook, and self.add_transform to be called from RbDsl
       end
 
-      protected
-
       def begin_scenario(scenario)
         begin_rb_scenario(scenario)
       end

data/lib/cucumber/rb_support/rb_world.rb

@@ -11,13 +11,6 @@ module Cucumber
       # @private
       AnsiEscapes = Gherkin::Formatter::AnsiEscapes
 
-      class << self
-        # @private
-        def alias_adverb(adverb)
-          alias_method adverb, :__cucumber_invoke
-        end
-      end
-
       # Call a Transform with a string from another Transform definition
       def Transform(arg)
         rb = @__cucumber_runtime.load_programming_language('rb')
@@ -27,12 +20,6 @@ module Cucumber
       # @private
       attr_writer :__cucumber_runtime, :__natural_language
 
-      # @private
-      def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
-        STDERR.puts AnsiEscapes.failed + "WARNING: Using 'Given/When/Then' in step definitions is deprecated, use 'step' to call other steps instead:" + caller[0] + AnsiEscapes.reset
-        @__cucumber_runtime.invoke(name, multiline_argument)
-      end
-
       # Run a single Gherkin step
       # @example Call another step
       #   step "I am logged in"
@@ -48,8 +35,11 @@ module Cucumber
       #   step "the email should contain:", "Dear sir,\nYou've won a prize!\n"
       # @param [String] name The name of the step
       # @param [String,Cucumber::Ast::DocString,Cucumber::Ast::Table] multiline_argument
-      def step(name, multiline_argument=nil)
-        @__cucumber_runtime.invoke(name, multiline_argument)
+      def step(name, raw_multiline_arg=nil)
+        # TODO: this argument parsing should move up out of core
+        location = Core::Ast::Location.new(*caller[0].split(':')[0..1])
+        core_multiline_arg = Core::Ast::MultilineArgument.from(raw_multiline_arg, location)
+        @__cucumber_runtime.invoke(name, MultilineArgument.from(core_multiline_arg))
       end
 
       # Run a snippet of Gherkin
@@ -102,7 +92,7 @@ module Cucumber
       #   of sending the output directly to STDOUT, Cucumber will intercept and cache
       #   the message until the current step has finished, and then display it.
       #   
-      #   If you'd prefer to see the message immediately, call {Kernel#puts} instead.
+      #   If you'd prefer to see the message immediately, call {Kernel.puts} instead.
       def puts(*messages)
         @__cucumber_runtime.puts(*messages)
       end
@@ -123,14 +113,19 @@ module Cucumber
           begin
             yield
           rescue Exception
-            raise Pending.new(message)
+            raise Pending, message
           end
-          raise Pending.new("Expected pending '#{message}' to fail. No Error was raised. No longer pending?")
+          raise Pending, "Expected pending '#{message}' to fail. No Error was raised. No longer pending?"
         else
-          raise Pending.new(message)
+          raise Pending, message
         end
       end
 
+      # Skips this step and the remaining steps in the scenario
+      def skip_this_scenario(message = "Scenario skipped")
+        raise Core::Test::Result::Skipped, message
+      end
+
       # Prints the list of modules that are included in the World
       def inspect
         modules = [self.class]

data/lib/cucumber/rb_support/snippet.rb

@@ -6,11 +6,11 @@ module Cucumber
 
       class BaseSnippet
 
-        def initialize(code_keyword, pattern, multiline_argument_class)
+        def initialize(code_keyword, pattern, multiline_argument)
           @number_of_arguments = 0
           @code_keyword = code_keyword
           @pattern = replace_and_count_capturing_groups(pattern)
-          @multiline_argument_class = multiline_argument_class
+          @multiline_argument = MultilineArgumentSnippet.new(multiline_argument)
         end
 
         def to_s
@@ -27,7 +27,7 @@ module Cucumber
 
         private
 
-        attr_reader :code_keyword, :pattern, :multiline_argument_class, :number_of_arguments
+        attr_reader :code_keyword, :pattern, :multiline_argument, :number_of_arguments
 
         def replace_and_count_capturing_groups(pattern)
           modified_pattern = ::Regexp.escape(pattern).gsub('\ ', ' ').gsub('/', '\/')
@@ -43,32 +43,20 @@ module Cucumber
         def do_block
           do_block = ""
           do_block << "do#{arguments}\n"
-          do_block << multiline_comment if multiline_argument_class?
-          do_block << "  pending # express the regexp above with the code you wish you had\n"
+          multiline_argument.append_comment_to(do_block)
+          do_block << "  pending # Write code here that turns the phrase above into concrete actions\n"
           do_block << "end"
           do_block
         end
 
         def arguments
           block_args = (0...number_of_arguments).map { |n| "arg#{n+1}" }
-
-          if multiline_argument_class
-            block_args << multiline_argument_class.default_arg_name
-          end
-
+          multiline_argument.append_block_argument_to(block_args)
           block_args.empty? ? "" : " |#{block_args.join(", ")}|"
         end
 
-        def multiline_comment
-          "  # #{multiline_argument_class.default_arg_name} is a #{multiline_argument_class.to_s}\n"
-        end
-
-        def multiline_argument_class?
-          multiline_argument_class == Ast::Table
-        end
-
         def self.example
-          new("Given", "missing step", nil).step
+          new("Given", "missing step", MultilineArgument::None.new).step
         end
 
       end
@@ -103,6 +91,59 @@ module Cucumber
         end
       end
 
+      module MultilineArgumentSnippet
+
+        def self.new(multiline_argument)
+          builder = Builder.new
+          multiline_argument.describe_to(builder)
+          builder.result
+        end
+
+        class Builder
+          def doc_string(*args)
+            @result = DocString.new
+          end
+
+          def data_table(table, *args)
+            @result = DataTable.new(table)
+          end
+
+          def result
+            @result || None.new
+          end
+        end
+
+        class DocString
+          def append_block_argument_to(array)
+            array << 'string'
+          end
+
+          def append_comment_to(string)
+          end
+        end
+
+        class DataTable
+          def initialize(table)
+            @table = table
+          end
+
+          def append_block_argument_to(array)
+            array << 'table'
+          end
+
+          def append_comment_to(string)
+            string << "  # table is a #{@table.class.to_s}\n"
+          end
+        end
+
+        class None
+          def append_block_argument_to(array)
+          end
+
+          def append_comment_to(string)
+          end
+        end
+      end
     end
   end
 end