kbaum-cucumber 0.4.5.pre

data/lib/cucumber/rb_support/rb_hook.rb

@@ -0,0 +1,19 @@
+module Cucumber
+  module RbSupport
+    # Wrapper for Before, After and AfterStep hooks
+    class RbHook
+      attr_accessor :tag_name_lists
+      attr_reader :tag_names
+      
+      def initialize(rb_language, tag_names, proc)
+        @rb_language = rb_language
+        @tag_names = tag_names
+        @proc = proc
+      end
+
+      def invoke(location, argument)
+        @rb_language.current_world.cucumber_instance_exec(false, location, argument, &@proc)
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_language.rb

@@ -0,0 +1,179 @@
+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'
+
+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/aslakhellesoy/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
+      
+      def initialize(step_mother)
+        @step_mother = step_mother
+        @step_definitions = []
+        RbDsl.rb_language = self
+        @world_proc = @world_modules = nil
+      end
+
+      # Tell the language about other i18n translations so that
+      # they can alias Given, When Then etc. Only useful if the language
+      # has a mechanism for this - typically a dynamic language.
+      def alias_adverbs(adverbs)
+        adverbs.each do |adverb|
+          RbDsl.alias_adverb(adverb)
+          RbWorld.alias_adverb(adverb)
+        end
+      end
+
+      # Gets called for each file under features (or whatever is overridden
+      # with --require).
+      def step_definitions_for(rb_file)
+        begin
+          require rb_file # This will cause self.add_step_definition and self.add_hook to be called from RbDsl
+          step_definitions
+        rescue LoadError => e
+          e.message << "\nFailed to load #{code_file}"
+          raise e
+        ensure
+          @step_definitions = nil
+        end
+      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(step_keyword, step_name, multiline_arg_class)
+        escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
+        escaped = escaped.gsub(PARAM_PATTERN, ESCAPED_PARAM_PATTERN)
+
+        n = 0
+        block_args = escaped.scan(ESCAPED_PARAM_PATTERN).map do |a|
+          n += 1
+          "arg#{n}"
+        end
+        block_args << multiline_arg_class.default_arg_name unless multiline_arg_class.nil?
+        block_arg_string = block_args.empty? ? "" : " |#{block_args.join(", ")}|"
+        multiline_class_comment = ""
+        if(multiline_arg_class == Ast::Table)
+          multiline_class_comment = "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  "
+        end
+
+        "#{step_keyword} /^#{escaped}$/ do#{block_arg_string}\n  #{multiline_class_comment}pending # express the regexp above with the code you wish you had\nend"
+      end
+
+      def begin_rb_scenario(scenario)
+        create_world
+        extend_world
+        connect_world(scenario)
+      end
+
+      def register_rb_hook(phase, tag_names, proc)
+        add_hook(phase, RbHook.new(self, tag_names, proc))
+      end
+
+      def register_rb_transform(regexp, proc)
+        add_transform(RbTransform.new(self, regexp, proc))
+      end
+
+      def register_rb_step_definition(regexp, proc)
+        step_definition = RbStepDefinition.new(self, regexp, proc)
+        @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)
+        require 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
+      
+      def end_scenario
+        @current_world = nil
+      end
+
+      private
+
+      PARAM_PATTERN = /"([^\"]*)"/
+      ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
+
+      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)
+        @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+        (@world_modules || []).each do |mod|
+          @current_world.extend(mod)
+        end
+      end
+
+      def connect_world(scenario)
+        @current_world.__cucumber_step_mother = @step_mother
+        @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
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -0,0 +1,75 @@
+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"
+        end
+      end
+
+      def initialize(rb_language, regexp, proc)
+        raise MissingProc if proc.nil?
+        if String === regexp
+          p = Regexp.escape(regexp)
+          p = p.gsub(/\\\$\w+/, '(.*)') # Replace $var with (.*)
+          regexp = Regexp.new("^#{p}$") 
+        end
+        @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 ==(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)
+        args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
+        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
+        @proc.file_colon_line
+      end
+    
+      def file
+        @file ||= file_colon_line.split(':')[0]
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_transform.rb

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

data/lib/cucumber/rb_support/rb_world.rb

@@ -0,0 +1,81 @@
+module Cucumber
+  module RbSupport
+    # All steps are run in the context of an object that extends this module.
+    module RbWorld
+      class << self
+        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_step_mother.load_programming_language('rb')
+        rb.execute_transforms([arg]).first
+      end
+    
+      attr_writer :__cucumber_step_mother, :__natural_language
+
+      # Call a step from within a step definition. This method is aliased to
+      # the same i18n as RbDsl.
+      def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
+        @__cucumber_step_mother.invoke(name, multiline_argument)
+      end
+
+      # See StepMother#invoke_steps
+      def steps(steps_text)
+        @__cucumber_step_mother.invoke_steps(steps_text, @__natural_language)
+      end
+
+      # See StepMother#table
+      def table(text_or_table, file=nil, line_offset=0)
+        @__cucumber_step_mother.table(text_or_table, file, line_offset)
+      end
+
+      # See StepMother#py_string
+      def py_string(string_with_triple_quotes, file=nil, line_offset=0)
+        @__cucumber_step_mother.py_string(text_or_table, file, line_offset)
+      end
+
+      # See StepMother#announce
+      def announce(announcement)
+        @__cucumber_step_mother.announce(announcement)
+      end
+
+      # See StepMother#embed
+      def embed(file, mime_type)
+        @__cucumber_step_mother.embed(file, mime_type)
+      end
+
+      # Mark the matched step as pending.
+      def pending(message = "TODO")
+        if block_given?
+          begin
+            yield
+          rescue Exception => e
+            raise Pending.new(message)
+          end
+          raise Pending.new("Expected pending '#{message}' to fail. No Error was raised. No longer pending?")
+        else
+          raise Pending.new(message)
+        end
+      end
+
+      # The default implementation of Object#inspect recursively
+      # traverses all instance variables and invokes inspect. 
+      # This can be time consuming if the object graph is large.
+      #
+      # This can cause unnecessary delays when certain exceptions 
+      # occur. For example, MRI internally invokes #inspect on an 
+      # object that raises a NoMethodError. (JRuby does not do this).
+      #
+      # A World object can have many references created by the user
+      # or frameworks (Rails), so to avoid long waiting times on
+      # such errors in World we define it to just return a simple String.
+      #
+      def inspect #:nodoc:
+        sprintf("#<%s:0x%x>", self.class, self.object_id)
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/regexp_argument_matcher.rb

@@ -0,0 +1,21 @@
+require 'cucumber/step_argument'
+
+module Cucumber
+  module RbSupport
+    class RegexpArgumentMatcher
+      def self.arguments_from(regexp, step_name)
+        match = regexp.match(step_name)
+        if match
+          n = 0
+          match.captures.map do |val|
+            n += 1
+            start = match.offset(n)[0]
+            StepArgument.new(val, start)
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/rspec_neuter.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+
+module Spec #:nodoc:
+  module Runner #:nodoc:
+    # Neuters RSpec's option parser.
+    # (RSpec's option parser tries to parse ARGV, which
+    # will fail when running cucumber)
+    class OptionParser < ::OptionParser #:nodoc:
+      NEUTERED_RSPEC = Object.new
+      def NEUTERED_RSPEC.method_missing(m, *args); self; end
+      
+      def self.method_added(m)
+        unless @__neutering_rspec
+          @__neutering_rspec = true
+          define_method(m) do |*a|
+            NEUTERED_RSPEC
+          end
+          @__neutering_rspec = false
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/step_argument.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  class StepArgument
+    attr_reader :val, :pos
+
+    def initialize(val, pos)
+      @val, @pos = val, pos
+    end
+  end
+end