cucumber 3.0.0.pre.1 → 4.0.0.rc.4

data/lib/cucumber/runtime/user_interface.rb

@@ -1,24 +1,12 @@
 # frozen_string_literal: true
+
 require 'timeout'
 
 module Cucumber
   class Runtime
-
     module UserInterface
       attr_writer :visitor
 
-      def visitor=(visitor)
-        @visitor = visitor
-      end
-
-      # Output +messages+ alongside the formatted output.
-      # This is an alternative to using Kernel#puts - it will display
-      # nicer, and in all outputs (in case you use several formatters)
-      #
-      def puts(*messages)
-        @visitor.puts(*messages)
-      end
-
       # Suspends execution and prompts +question+ to the console (STDOUT).
       # An operator (manual tester) can then enter a line of text and hit
       # <ENTER>. The entered text is returned, and both +question+ and
@@ -37,38 +25,33 @@ module Cucumber
         STDOUT.flush
         puts(question)
 
-        if(Cucumber::JRUBY)
-          answer = jruby_gets(timeout_seconds)
-        else
-          answer = mri_gets(timeout_seconds)
-        end
+        answer = if Cucumber::JRUBY
+                   jruby_gets(timeout_seconds)
+                 else
+                   mri_gets(timeout_seconds)
+                 end
 
-        if(answer)
-          puts(answer)
-          answer
-        else
-          raise("Waited for input for #{timeout_seconds} seconds, then timed out.")
-        end
+        raise("Waited for input for #{timeout_seconds} seconds, then timed out.") unless answer
+        puts(answer)
+        answer
       end
 
       # Embed +src+ of MIME type +mime_type+ into the output. The +src+ argument may
       # be a path to a file, or if it's an image it may also be a Base64 encoded image.
       # The embedded data may or may not be ignored, depending on what kind of formatter(s) are active.
       #
-      def embed(src, mime_type, label)
-        @visitor.embed(src, mime_type, label)
+      def attach(src, media_type)
+        @visitor.attach(src, media_type)
       end
 
-    private
+      private
 
       def mri_gets(timeout_seconds)
-        begin
-          Timeout.timeout(timeout_seconds) do
-            STDIN.gets
-          end
-        rescue Timeout::Error
-          nil
+        Timeout.timeout(timeout_seconds) do
+          STDIN.gets
         end
+      rescue Timeout::Error
+        nil
       end
 
       def jruby_gets(timeout_seconds)
@@ -81,6 +64,5 @@ module Cucumber
         answer
       end
     end
-
   end
 end

data/lib/cucumber/step_definition_light.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
+
 module Cucumber
+  # TODO: pointless, ancient, kill with fire.
   # Only used for keeping track of available and invoked step definitions
   # in a way that also works for other programming languages (i.e. cuke4duke)
   # Used for reporting purposes only (usage formatter).
@@ -7,15 +9,16 @@ module Cucumber
     attr_reader :regexp_source, :location
 
     def initialize(regexp_source, location)
-      @regexp_source, @location = regexp_source, location
+      @regexp_source = regexp_source
+      @location = location
     end
 
-    def eql?(o)
-      regexp_source == o.regexp_source && location == o.location
+    def eql?(other)
+      regexp_source == other.regexp_source && location == other.location
     end
 
     def hash
-      regexp_source.hash + 31*location.to_s.hash
+      regexp_source.hash + 31 * location.to_s.hash
     end
   end
 end

data/lib/cucumber/step_definitions.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   class StepDefinitions
     def initialize(configuration = Configuration.default)
@@ -7,8 +8,8 @@ module Cucumber
       @support_code.load_files_from_paths(configuration.autoload_code_paths)
     end
 
-    def to_json
-      @support_code.step_definitions.map{|stepdef| stepdef.to_hash}.to_json
+    def to_json(obj = nil)
+      @support_code.step_definitions.map(&:to_hash).to_json(obj)
     end
   end
 end

data/lib/cucumber/step_match.rb

@@ -1,24 +1,29 @@
 # frozen_string_literal: true
+
 require 'cucumber/multiline_argument'
 
 module Cucumber
-
   # Represents the match found between a Test Step and its activation
   class StepMatch #:nodoc:
     attr_reader :step_definition, :step_arguments
 
     def initialize(step_definition, step_name, step_arguments)
       raise "step_arguments can't be nil (but it can be an empty array)" if step_arguments.nil?
-      @step_definition, @name_to_match, @step_arguments = step_definition, step_name, step_arguments
+      @step_definition = step_definition
+      @name_to_match = step_name
+      @step_arguments = step_arguments
     end
 
     def args
-      @step_arguments.map{|g| g.val }
+      current_world = @step_definition.registry.current_world
+      @step_arguments.map do |arg|
+        arg.value(current_world)
+      end
     end
 
     def activate(test_step)
       test_step.with_action(@step_definition.location) do
-        invoke(MultilineArgument.from_core(test_step.source.last.multiline_arg))
+        invoke(MultilineArgument.from_core(test_step.multiline_arg))
       end
     end
 
@@ -43,7 +48,7 @@ module Cucumber
     #
     #   lambda { |param| "[#{param}]" }
     #
-    def format_args(format = lambda{|a| a}, &proc)
+    def format_args(format = ->(a) { a }, &proc)
       replace_arguments(@name_to_match, @step_arguments, format, &proc)
     end
 
@@ -56,30 +61,31 @@ module Cucumber
     end
 
     def backtrace_line
-      "#{file_colon_line}:in `#{@step_definition.regexp_source}'"
+      "#{file_colon_line}:in `#{@step_definition.expression}'"
     end
 
     def text_length
-      @step_definition.regexp_source.unpack('U*').length
+      @step_definition.expression.source.to_s.unpack('U*').length
     end
 
-    def replace_arguments(string, step_arguments, format, &proc)
+    def replace_arguments(string, step_arguments, format)
       s = string.dup
       offset = past_offset = 0
       step_arguments.each do |step_argument|
-        next if step_argument.offset.nil? || step_argument.offset < past_offset
+        group = step_argument.group
+        next if group.value.nil? || group.start < past_offset
 
         replacement = if block_given?
-          proc.call(step_argument.val)
-        elsif Proc === format
-          format.call(step_argument.val)
-        else
-          format % step_argument.val
-        end
-
-        s[step_argument.offset + offset, step_argument.val.length] = replacement
-        offset += replacement.unpack('U*').length - step_argument.val.unpack('U*').length
-        past_offset = step_argument.offset + step_argument.val.length
+                        yield(group.value)
+                      elsif Proc == format.class
+                        format.call(group.value)
+                      else
+                        format % group.value
+                      end
+
+        s[group.start + offset, group.value.length] = replacement
+        offset += replacement.unpack('U*').length - group.value.unpack('U*').length
+        past_offset = group.start + group.value.length
       end
       s
     end
@@ -89,14 +95,15 @@ module Cucumber
     end
 
     private
+
     def deep_clone_args
-      Marshal.load( Marshal.dump( args ) )
+      Marshal.load(Marshal.dump(args))
     end
   end
 
   class SkippingStepMatch
     def activate(test_step)
-      return test_step.with_action { raise Core::Test::Result::Skipped.new }
+      test_step.with_action { raise Core::Test::Result::Skipped }
     end
   end
 
@@ -108,7 +115,7 @@ module Cucumber
       @name = name
     end
 
-    def format_args(*args)
+    def format_args(*_args)
       @name
     end
 
@@ -118,8 +125,7 @@ module Cucumber
     end
 
     def file_colon_line
-      raise "No file:line for #{@step}" unless @step.file_colon_line
-      @step.file_colon_line
+      location.to_s
     end
 
     def backtrace_line
@@ -127,7 +133,7 @@ module Cucumber
     end
 
     def text_length
-      @step.text_length
+      @step.text.length
     end
 
     def step_arguments
@@ -136,7 +142,17 @@ module Cucumber
 
     def activate(test_step)
       # noop
-      return test_step
+      test_step
+    end
+  end
+
+  class AmbiguousStepMatch
+    def initialize(error)
+      @error = error
+    end
+
+    def activate(test_step)
+      test_step.with_action { raise @error }
     end
   end
 end

data/lib/cucumber/step_match_search.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   module StepMatchSearch
     def self.new(search, configuration)
@@ -12,7 +13,8 @@ module Cucumber
 
     class AssertUnambiguousMatch
       def initialize(search, configuration)
-        @search, @configuration = search, configuration
+        @search = search
+        @configuration = configuration
       end
 
       def call(step_name)
@@ -33,22 +35,21 @@ module Cucumber
 
       private
 
-      def best_matches(step_name, step_matches) #:nodoc:
-        no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
-        max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
-        top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
+      def best_matches(_step_name, step_matches) #:nodoc:
+        no_groups      = step_matches.select { |step_match| step_match.args.empty? }
+        max_arg_length = step_matches.map { |step_match| step_match.args.length }.max
+        top_groups     = step_matches.select { |step_match| step_match.args.length == max_arg_length }
 
         if no_groups.any?
-          longest_regexp_length = no_groups.map {|step_match| step_match.text_length }.max
-          no_groups.select {|step_match| step_match.text_length == longest_regexp_length }
+          longest_regexp_length = no_groups.map(&:text_length).max
+          no_groups.select { |step_match| step_match.text_length == longest_regexp_length }
         elsif top_groups.any?
-          shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } }.min
-          top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.to_s.length } == shortest_capture_length }
+          shortest_capture_length = top_groups.map { |step_match| step_match.args.inject(0) { |sum, c| sum + c.to_s.length } }.min
+          top_groups.select { |step_match| step_match.args.inject(0) { |sum, c| sum + c.to_s.length } == shortest_capture_length }
         else
           top_groups
         end
       end
-
     end
 
     require 'delegate'
@@ -62,7 +63,5 @@ module Cucumber
         @match_cache[step_name] = super(step_name)
       end
     end
-
   end
 end
-

data/lib/cucumber/term/ansicolor.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Term
     # The ANSIColor module can be used for namespacing and mixed into your own
@@ -6,35 +7,35 @@ module Cucumber
     module ANSIColor
       # :stopdoc:
       ATTRIBUTES = [
-        [ :clear        ,   0 ],
-        [ :reset        ,   0 ],     # synonym for :clear
-        [ :bold         ,   1 ],
-        [ :dark         ,   2 ],
-        [ :italic       ,   3 ],     # not widely implemented
-        [ :underline    ,   4 ],
-        [ :underscore   ,   4 ],     # synonym for :underline
-        [ :blink        ,   5 ],
-        [ :rapid_blink  ,   6 ],     # not widely implemented
-        [ :negative     ,   7 ],     # no reverse because of String#reverse
-        [ :concealed    ,   8 ],
-        [ :strikethrough,   9 ],     # not widely implemented
-        [ :black        ,  30 ],
-        [ :red          ,  31 ],
-        [ :green        ,  32 ],
-        [ :yellow       ,  33 ],
-        [ :blue         ,  34 ],
-        [ :magenta      ,  35 ],
-        [ :cyan         ,  36 ],
-        [ :white        ,  37 ],
-        [ :on_black     ,  40 ],
-        [ :on_red       ,  41 ],
-        [ :on_green     ,  42 ],
-        [ :on_yellow    ,  43 ],
-        [ :on_blue      ,  44 ],
-        [ :on_magenta   ,  45 ],
-        [ :on_cyan      ,  46 ],
-        [ :on_white     ,  47 ],
-      ]
+        [:clear,         0],
+        [:reset,         0], # synonym for :clear
+        [:bold,          1],
+        [:dark,          2],
+        [:italic,        3], # not widely implemented
+        [:underline,     4],
+        [:underscore,    4], # synonym for :underline
+        [:blink,         5],
+        [:rapid_blink,   6], # not widely implemented
+        [:negative,      7], # no reverse because of String#reverse
+        [:concealed,     8],
+        [:strikethrough, 9], # not widely implemented
+        [:black,         30],
+        [:red,           31],
+        [:green,         32],
+        [:yellow,        33],
+        [:blue,          34],
+        [:magenta,       35],
+        [:cyan,          36],
+        [:white,         37],
+        [:on_black,      40],
+        [:on_red,        41],
+        [:on_green,      42],
+        [:on_yellow,     43],
+        [:on_blue,       44],
+        [:on_magenta,    45],
+        [:on_cyan,       46],
+        [:on_white,      47]
+      ].freeze
 
       ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
       # :startdoc:
@@ -53,10 +54,11 @@ module Cucumber
       end
       self.coloring = true
 
+      # rubocop:disable Security/Eval
       ATTRIBUTES.each do |c, v|
-        eval %Q{
+        eval <<-END_EVAL, binding, __FILE__, __LINE__ + 1
             def #{c}(string = nil)
-              result = ''
+              result = String.new
               result << "\e[#{v}m" if Cucumber::Term::ANSIColor.coloring?
               if block_given?
                 result << yield
@@ -70,24 +72,23 @@ module Cucumber
               result << "\e[0m" if Cucumber::Term::ANSIColor.coloring?
               result
             end
-        }
+        END_EVAL
       end
+      # rubocop:enable Security/Eval
 
       # Regular expression that is used to scan for ANSI-sequences while
       # uncoloring strings.
       COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
 
-
       def self.included(klass)
-        if klass == String
-          ATTRIBUTES.delete(:clear)
-          ATTRIBUTE_NAMES.delete(:clear)
-        end
+        return unless klass == String
+        ATTRIBUTES.delete(:clear)
+        ATTRIBUTE_NAMES.delete(:clear)
       end
 
       # Returns an uncolored version of the string, that is all
       # ANSI-sequences are stripped from the string.
-      def uncolored(string = nil) # :yields:
+      def uncolored(string = nil)
         if block_given?
           yield.gsub(COLORED_REGEXP, '')
         elsif string
@@ -105,7 +106,6 @@ module Cucumber
       def attributes
         ATTRIBUTE_NAMES
       end
-      extend self
     end
   end
 end