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

data/lib/cucumber/rb_support/rb_hook.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-module Cucumber
-  module RbSupport
-    # Wrapper for Before, After and AfterStep hooks
-    class RbHook
-      attr_reader :tag_expressions, :location
-
-      def initialize(rb_language, tag_expressions, proc)
-        @rb_language = rb_language
-        @tag_expressions = tag_expressions
-        @proc = proc
-        @location = Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
-      end
-
-      def invoke(pseudo_method, arguments, &block)
-        @rb_language.current_world.cucumber_instance_exec(false, pseudo_method, *[arguments, block].flatten.compact, &@proc)
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_language.rb

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core_ext/instance_exec'
-require 'cucumber/rb_support/rb_dsl'
-require 'cucumber/rb_support/rb_world'
-require 'cucumber/rb_support/rb_step_definition'
-require 'cucumber/rb_support/rb_hook'
-require 'cucumber/rb_support/rb_transform'
-require 'cucumber/rb_support/snippet'
-require 'cucumber/gherkin/i18n'
-require 'multi_test'
-require 'cucumber/step_match'
-require 'cucumber/step_definition_light'
-require 'cucumber/events/step_definition_registered'
-
-module Cucumber
-  module RbSupport
-    # Raised if a World block returns Nil.
-    class NilWorld < StandardError
-      def initialize
-        super("World procs should never return nil")
-      end
-    end
-
-    # Raised if there are 2 or more World blocks.
-    class MultipleWorld < StandardError
-      def initialize(first_proc, second_proc)
-        message = String.new
-        message << "You can only pass a proc to #World once, but it's happening\n"
-        message << "in 2 places:\n\n"
-        message << RbSupport.backtrace_line(first_proc, 'World') << "\n"
-        message << RbSupport.backtrace_line(second_proc, 'World') << "\n\n"
-        message << "Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc\n"
-        message << "or http://wiki.github.com/cucumber/cucumber/a-whole-new-world.\n\n"
-        super(message)
-      end
-    end
-
-    # The Ruby implementation of the programming language API.
-    class RbLanguage
-      attr_reader :current_world,
-                  :step_definitions
-
-      all_keywords = ::Gherkin::DIALECTS.keys.map do |dialect_name|
-        dialect = ::Gherkin::Dialect.for(dialect_name)
-        dialect.given_keywords + dialect.when_keywords + dialect.then_keywords + dialect.and_keywords + dialect.but_keywords
-      end
-      Cucumber::Gherkin::I18n.code_keywords_for(all_keywords.flatten.uniq.sort).each do |adverb|
-        RbDsl.alias_adverb(adverb.strip)
-      end
-
-      def initialize(runtime, configuration)
-        @runtime, @configuration = runtime, configuration
-        @step_definitions = []
-        RbDsl.rb_language = self
-        @world_proc = @world_modules = nil
-        @configuration.register_snippet_generator(Snippet::Generator.new)
-      end
-
-      def step_matches(name_to_match)
-        @step_definitions.reduce([]) { |result, step_definition|
-          if (arguments = step_definition.arguments_from(name_to_match))
-            result << StepMatch.new(step_definition, name_to_match, arguments)
-          end
-          result
-        }
-      end
-
-      def begin_rb_scenario(scenario)
-        create_world
-        extend_world
-        connect_world(scenario)
-      end
-
-      def register_rb_hook(phase, tag_expressions, proc)
-        add_hook(phase, RbHook.new(self, tag_expressions, proc))
-      end
-
-      def register_rb_transform(regexp, proc)
-        add_transform(RbTransform.new(self, regexp, proc))
-      end
-
-      def register_rb_step_definition(regexp, proc_or_sym, options)
-        step_definition = RbStepDefinition.new(self, regexp, proc_or_sym, options)
-        @step_definitions << step_definition
-        @configuration.notify :step_definition_registered, step_definition
-        step_definition
-      end
-
-      def build_rb_world_factory(world_modules, namespaced_world_modules, proc)
-        if proc
-          raise MultipleWorld.new(@world_proc, proc) if @world_proc
-          @world_proc = proc
-        end
-        @world_modules ||= []
-        @world_modules += world_modules
-
-        @namespaced_world_modules ||= Hash.new { |h, k| h[k] = [] }
-        namespaced_world_modules.each do |namespace, world_module|
-          unless @namespaced_world_modules[namespace].include?(world_module)
-            @namespaced_world_modules[namespace] << world_module
-          end
-        end
-      end
-
-      def load_code_file(code_file)
-        return unless File.extname(code_file) == ".rb"
-        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
-
-      def begin_scenario(scenario)
-        begin_rb_scenario(scenario)
-      end
-
-      def end_scenario
-        @current_world = nil
-      end
-
-      def after_configuration(configuration)
-        hooks[:after_configuration].each do |hook|
-          hook.invoke('AfterConfiguration', configuration)
-        end
-      end
-
-      def execute_transforms(args)
-        args.map do |arg|
-          matching_transform = transforms.detect {|transform| transform.match(arg) }
-          matching_transform ? matching_transform.invoke(arg) : arg
-        end
-      end
-
-      def add_hook(phase, hook)
-        hooks[phase.to_sym] << hook
-        hook
-      end
-
-      def clear_hooks
-        @hooks = nil
-      end
-
-      def add_transform(transform)
-        transforms.unshift transform
-        transform
-      end
-
-      def hooks_for(phase, scenario) #:nodoc:
-        hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
-      end
-
-      def unmatched_step_definitions
-        available_step_definition_hash.keys - invoked_step_definition_hash.keys
-      end
-
-      def available_step_definition(regexp_source, file_colon_line)
-        available_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
-      end
-
-      def invoked_step_definition(regexp_source, file_colon_line)
-        invoked_step_definition_hash[StepDefinitionLight.new(regexp_source, file_colon_line)] = nil
-      end
-
-      private
-
-      def available_step_definition_hash
-        @available_step_definition_hash ||= {}
-      end
-
-      def invoked_step_definition_hash
-        @invoked_step_definition_hash ||= {}
-      end
-
-      def hooks
-        @hooks ||= Hash.new{|h,k| h[k] = []}
-      end
-
-      def transforms
-        @transforms ||= []
-      end
-
-      def create_world
-        if(@world_proc)
-          @current_world = @world_proc.call
-          check_nil(@current_world, @world_proc)
-        else
-          @current_world = Object.new
-        end
-      end
-
-      def extend_world
-        @current_world.extend(RbWorld)
-        MultiTest.extend_with_best_assertion_library(@current_world)
-
-        @current_world.add_modules!(@world_modules || [],
-                                    @namespaced_world_modules || {})
-      end
-
-      def connect_world(scenario)
-        @current_world.__cucumber_runtime = @runtime
-        @current_world.__natural_language = scenario.language
-      end
-
-      def check_nil(o, proc)
-        if o.nil?
-          begin
-            raise NilWorld.new
-          rescue NilWorld => e
-            e.backtrace.clear
-            e.backtrace.push(RbSupport.backtrace_line(proc, "World"))
-            raise e
-          end
-        else
-          o
-        end
-      end
-
-      def self.cli_snippet_type_options
-        Snippet::SNIPPET_TYPES.keys.sort_by(&:to_s).map do |type|
-          Snippet::SNIPPET_TYPES[type].cli_option_string(type)
-        end
-      end
-    end
-
-    def self.backtrace_line(proc, name)
-      location = Cucumber::Core::Ast::Location.from_source_location(*proc.source_location)
-      "#{location.to_s}:in `#{name}'"
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/step_match'
-require 'cucumber/step_argument'
-require 'cucumber/core_ext/string'
-
-module Cucumber
-  module RbSupport
-    # A Ruby Step Definition holds a Regexp and a Proc, and is created
-    # by calling <tt>Given</tt>, <tt>When</tt> or <tt>Then</tt>
-    # in the <tt>step_definitions</tt> ruby files. See also RbDsl.
-    #
-    # Example:
-    #
-    #   Given /I have (\d+) cucumbers in my belly/ do
-    #     # some code here
-    #   end
-    #
-    class RbStepDefinition
-
-      class MissingProc < StandardError
-        def message
-          "Step definitions must always have a proc or symbol"
-        end
-      end
-
-      class << self
-        def new(rb_language, pattern, proc_or_sym, options)
-          raise MissingProc if proc_or_sym.nil?
-          super rb_language, parse_pattern(pattern), create_proc(proc_or_sym, options)
-        end
-
-        private
-
-        def parse_pattern(pattern)
-          return pattern if pattern.is_a?(Regexp)
-          raise ArgumentError unless pattern.is_a?(String)
-          p = Regexp.escape(pattern)
-          p = p.gsub(/\\\$\w+/, '(.*)') # Replace $var with (.*)
-          Regexp.new("^#{p}$")
-        end
-
-        def create_proc(proc_or_sym, options)
-          return proc_or_sym if proc_or_sym.is_a?(Proc)
-          raise ArgumentError unless proc_or_sym.is_a?(Symbol)
-          message = proc_or_sym
-          target_proc = parse_target_proc_from(options)
-          patch_location_onto lambda { |*args|
-            target = instance_exec(&target_proc)
-            target.send(message, *args)
-          }
-        end
-
-        def patch_location_onto(block)
-          location = Core::Ast::Location.of_caller(5)
-          block.define_singleton_method(:source_location) { [location.file, location.line] }
-          block
-        end
-
-        def parse_target_proc_from(options)
-          return lambda { self } unless options.key?(:on)
-          target = options[:on]
-          case target
-          when Proc
-            target
-          when Symbol
-            lambda { self.send(target) }
-          else
-            lambda { raise ArgumentError, "Target must be a symbol or a proc" }
-          end
-        end
-      end
-
-      def initialize(rb_language, regexp, proc)
-        @rb_language, @regexp, @proc = rb_language, regexp, proc
-        @rb_language.available_step_definition(regexp_source, location)
-      end
-
-      def regexp_source
-        @regexp.inspect
-      end
-
-      def to_hash
-        flags = ''
-        flags += 'm' if (@regexp.options & Regexp::MULTILINE) != 0
-        flags += 'i' if (@regexp.options & Regexp::IGNORECASE) != 0
-        flags += 'x' if (@regexp.options & Regexp::EXTENDED) != 0
-        {'source' => @regexp.source, 'flags' => flags}
-      end
-
-      def ==(step_definition)
-        regexp_source == step_definition.regexp_source
-      end
-
-      def arguments_from(step_name)
-        args = StepArgument.arguments_from(@regexp, step_name)
-        @rb_language.invoked_step_definition(regexp_source, location) if args
-        args
-      end
-
-      def invoke(args)
-        begin
-          args = @rb_language.execute_transforms(args)
-          @rb_language.current_world.cucumber_instance_exec(true, regexp_source, *args, &@proc)
-        rescue Cucumber::ArityMismatchError => e
-          e.backtrace.unshift(self.backtrace_line)
-          raise e
-        end
-      end
-
-      def backtrace_line
-        "#{location.to_s}:in `#{regexp_source}'"
-      end
-
-      def file_colon_line
-        case @proc
-        when Proc
-          location.to_s
-        when Symbol
-          ":#{@proc}"
-        end
-      end
-
-      def location
-        @location ||= Cucumber::Core::Ast::Location.from_source_location(*@proc.source_location)
-      end
-
-      def file
-        @file ||= location.file
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_transform.rb

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-module Cucumber
-  module RbSupport
-    # A Ruby Transform holds a Regexp and a Proc, and is created
-    # by calling <tt>Transform in the <tt>support</tt> ruby files.
-    # See also RbDsl.
-    #
-    # Example:
-    #
-    #   Transform /^(\d+) cucumbers$/ do |cucumbers_string|
-    #     cucumbers_string.to_i
-    #   end
-    #
-    class RbTransform
-      class MissingProc < StandardError
-        def message
-          "Transforms must always have a proc with at least one argument"
-        end
-      end
-
-      def initialize(rb_language, pattern, proc)
-        raise MissingProc if proc.nil? || proc.arity < 1
-        @rb_language, @regexp, @proc = rb_language, Regexp.new(pattern), proc
-      end
-
-      def match(arg)
-        arg ? arg.match(@regexp) : nil
-      end
-
-      def invoke(arg)
-        if matched = match(arg)
-          args = matched.captures.empty? ? [arg] : matched.captures
-          @rb_language.current_world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
-        end
-      end
-
-      def to_s
-         convert_captures(strip_anchors(@regexp.source))
-      end
-
-    private
-      def convert_captures(regexp_source)
-        regexp_source
-          .gsub(/(\()(?!\?[<:=!])/,'(?:')
-          .gsub(/(\(\?<)(?![=!])/,'(?:<')
-      end
-
-      def strip_captures(regexp_source)
-        regexp_source.
-          gsub(/(\()/, '').
-          gsub(/(\))/, '')
-      end
-
-      def strip_anchors(regexp_source)
-        regexp_source.
-          gsub(/(^\^|\$$)/, '')
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_world.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/gherkin/formatter/ansi_escapes'
-
-module Cucumber
-  module RbSupport
-    # Defines the basic DSL methods availlable in all Cucumber step definitions.
-    #
-    # You can, and probably should, extend this DSL with your own methods that
-    # make sense in your domain. For more on that, see {Cucumber::RbSupport::RbDsl#World}
-    module RbWorld
-
-      # @private
-      AnsiEscapes = Cucumber::Gherkin::Formatter::AnsiEscapes
-
-      # Call a Transform with a string from another Transform definition
-      def Transform(arg)
-        rb = @__cucumber_runtime.support_code.ruby
-        rb.execute_transforms([arg]).first
-      end
-
-      # @private
-      attr_writer :__cucumber_runtime, :__natural_language
-
-      # Extend the World with user-defined modules
-      def add_modules!(world_modules, namespaced_world_modules)
-        add_world_modules!(world_modules)
-        add_namespaced_modules!(namespaced_world_modules)
-      end
-
-      # Run a single Gherkin step
-      # @example Call another step
-      #   step "I am logged in"
-      # @example Call a step with quotes in the name
-      #   step %{the user "Dave" is logged in}
-      # @example Passing a table
-      #   step "the following users exist:", table(%{
-      #     | name  | email           |
-      #     | Matt  | matt@matt.com   |
-      #     | Aslak | aslak@aslak.com |
-      #   })
-      # @example Passing a multiline string
-      #   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, raw_multiline_arg=nil)
-        location = Core::Ast::Location.of_caller
-        @__cucumber_runtime.invoke_dynamic_step(name, MultilineArgument.from(raw_multiline_arg, location))
-      end
-
-      # Run a snippet of Gherkin
-      # @example
-      #   steps %{
-      #     Given the user "Susan" exists
-      #     And I am logged in as "Susan"
-      #   }
-      # @param [String] steps_text The Gherkin snippet to run
-      def steps(steps_text)
-        location = Core::Ast::Location.of_caller
-        @__cucumber_runtime.invoke_dynamic_steps(steps_text, @__natural_language, location)
-      end
-
-      # Parse Gherkin into a {Cucumber::Ast::Table} object.
-      #
-      # Useful in conjunction with the #step method.
-      # @example Create a table
-      #   users = table(%{
-      #     | name  | email           |
-      #     | Matt  | matt@matt.com   |
-      #     | Aslak | aslak@aslak.com |
-      #   })
-      # @param [String] text_or_table The Gherkin string that represents the table
-      def table(text_or_table, file=nil, line_offset=0)
-        @__cucumber_runtime.table(text_or_table, file, line_offset)
-      end
-
-      # Print a message to the output.
-      #
-      # @note Cucumber might surprise you with the behaviour of this method. Instead
-      #   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.
-      def puts(*messages)
-        # Even though they won't be output until later, converting the messages to
-        # strings right away will protect them from modifications to their original
-        # objects in the mean time
-        messages.collect! { |message| "#{message}" }
-
-        @__cucumber_runtime.puts(*messages)
-      end
-
-      # Pause the tests and ask the operator for input
-      def ask(question, timeout_seconds=60)
-        @__cucumber_runtime.ask(question, timeout_seconds)
-      end
-
-      # Embed an image in the output
-      def embed(file, mime_type, label='Screenshot')
-        @__cucumber_runtime.embed(file, mime_type, label)
-      end
-
-      # Mark the matched step as pending.
-      def pending(message = "TODO")
-        if block_given?
-          begin
-            yield
-          rescue Exception
-            raise Pending, message
-          end
-          raise Pending, "Expected pending '#{message}' to fail. No Error was raised. No longer pending?"
-        else
-          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]
-        (class << self; self; end).instance_eval do
-          modules += included_modules
-        end
-        modules << stringify_namespaced_modules
-        sprintf("#<%s:0x%x>", modules.join('+'), self.object_id)
-      end
-
-      # see {#inspect}
-      def to_s
-        inspect
-      end
-
-      private
-
-      # @private
-      def add_world_modules!(modules)
-        modules.each do |world_module|
-          extend(world_module)
-        end
-      end
-
-      # @private
-      def add_namespaced_modules!(modules)
-        @__namespaced_modules = modules
-        modules.each do |namespace, world_modules|
-          world_modules.each do |world_module|
-            variable_name = "@__#{namespace}_world"
-
-            inner_world = if self.class.respond_to?(namespace)
-                            instance_variable_get(variable_name)
-                          else
-                            Object.new
-                          end
-            instance_variable_set(variable_name,
-                                  inner_world.extend(world_module))
-            self.class.send(:define_method, namespace) do
-              instance_variable_get(variable_name)
-            end
-          end
-        end
-      end
-
-      def stringify_namespaced_modules
-        @__namespaced_modules.map { |k, v| "#{v.join(',')} (as #{k})" }.join('+')
-      end
-    end
-  end
-end