cucumber 2.0.0.rc.5 → 4.0.0.rc.3

data/lib/cucumber/language_support.rb

@@ -1,30 +0,0 @@
-module Cucumber
-  # This module defines the API for programming language support in Cucumber.
-  # While Cucumber itself is written in Ruby, any programming language can
-  # be supported by implementing this API.
-  #
-  # For the sake of illustration we'll consider an imaginary language called
-  # _why. _why files have the .why extension, so we need to put support for
-  # this language in the <tt>Cucumber::WhySupport::WhyLanguage</tt>. This
-  # class must be defined in a file called <tt>cucumber/why_support/why_language.rb</tt>
-  # and be available on Ruby's <tt>$LOAD_PATH</tt>:
-  #
-  #   module Cucumber
-  #     module WhySupport
-  #       class WhyLanguage
-  #
-  #         # Uses whatever available language bridge to load
-  #         # +why_file+ and returns an Array of StepDefinition.
-  #         def load_code_file(why_file)
-  #         end
-  #       end
-  #     end
-  #   end
-  #
-  # Each language implementation manages its own hooks, and must execute them
-  # at appropriate times.
-  #
-  #
-  module LanguageSupport
-  end
-end

data/lib/cucumber/language_support/language_methods.rb

@@ -1,71 +0,0 @@
-require 'cucumber/step_match'
-require 'cucumber/step_definition_light'
-
-module Cucumber
-  module LanguageSupport
-    module LanguageMethods
-
-      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
-
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_hook.rb

@@ -1,18 +0,0 @@
-module Cucumber
-  module RbSupport
-    # Wrapper for Before, After and AfterStep hooks
-    class RbHook
-      attr_reader :tag_expressions
-
-      def initialize(rb_language, tag_expressions, proc)
-        @rb_language = rb_language
-        @tag_expressions = tag_expressions
-        @proc = proc
-      end
-
-      def invoke(pseudo_method, arguments, &block)
-        @rb_language.current_world.cucumber_instance_exec(false, pseudo_method, *[arguments, block].compact, &@proc)
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_language.rb

@@ -1,160 +0,0 @@
-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 'multi_test'
-
-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 = "You can only pass a proc to #World once, but it's happening\n"
-        message << "in 2 places:\n\n"
-        message << first_proc.backtrace_line('World') << "\n"
-        message << second_proc.backtrace_line('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
-      include LanguageSupport::LanguageMethods
-      attr_reader :current_world,
-                  :step_definitions
-
-      Gherkin::I18n.code_keywords.each do |adverb|
-        RbDsl.alias_adverb(adverb)
-      end
-
-      def initialize(runtime)
-        @runtime = runtime
-        @step_definitions = []
-        RbDsl.rb_language = self
-        @world_proc = @world_modules = nil
-      end
-
-      def step_matches(name_to_match, name_to_format)
-        @step_definitions.map do |step_definition|
-          if(arguments = step_definition.arguments_from(name_to_match))
-            StepMatch.new(step_definition, name_to_match, name_to_format, arguments)
-          else
-            nil
-          end
-        end.compact
-      end
-
-      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).to_s
-      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
-        step_definition
-      end
-
-      def build_rb_world_factory(world_modules, proc)
-        if(proc)
-          raise MultipleWorld.new(@world_proc, proc) if @world_proc
-          @world_proc = proc
-        end
-        @world_modules ||= []
-        @world_modules += world_modules
-      end
-
-      def load_code_file(code_file)
-        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
-
-      private
-
-      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)
-        (@world_modules || []).each do |mod|
-          @current_world.extend(mod)
-        end
-      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(proc.backtrace_line("World"))
-            raise e
-          end
-        else
-          o
-        end
-      end
-
-      SNIPPET_TYPES = {
-        :regexp => Snippet::Regexp,
-        :classic => Snippet::Classic,
-        :percent => Snippet::Percent
-      }
-
-      def typed_snippet_class(type)
-        SNIPPET_TYPES.fetch(type || :regexp)
-      end
-
-      def self.cli_snippet_type_options
-        SNIPPET_TYPES.keys.sort_by(&:to_s).map do |type|
-          SNIPPET_TYPES[type].cli_option_string(type)
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -1,131 +0,0 @@
-require 'cucumber/step_match'
-require 'cucumber/core_ext/string'
-require 'cucumber/core_ext/proc'
-require 'cucumber/rb_support/regexp_argument_matcher'
-
-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)
-          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)
-          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, file_colon_line)
-      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 = RegexpArgumentMatcher.arguments_from(@regexp, step_name)
-        @rb_language.invoked_step_definition(regexp_source, file_colon_line) 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
-        @proc.backtrace_line(regexp_source)
-      end
-
-      def file_colon_line
-        case @proc
-        when Proc
-          @proc.file_colon_line
-        when Symbol
-          ":#{@proc}"
-        end
-      end
-
-      def file
-        @file ||= file_colon_line.split(':')[0]
-      end
-    end
-  end
-end

data/lib/cucumber/rb_support/rb_transform.rb

@@ -1,59 +0,0 @@
-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