aslakhellesoy-cucumber 0.3.95 → 0.3.96

data/lib/cucumber/cli/options.rb

@@ -218,6 +218,9 @@ module Cucumber
           opts.on(DRB_FLAG, "Run features against a DRb server. (i.e. with the spork gem)") do
             @options[:drb] = true
           end
+          opts.on("--port PORT", "Specify DRb port.  Ignored without --drb") do |port|
+            @options[:drb_port] = port
+          end
           opts.on_tail("--version", "Show version.") do
             @out_stream.puts VERSION::STRING
             Kernel.exit

data/lib/cucumber/constantize.rb

@@ -0,0 +1,28 @@
+module Cucumber
+  module Constantize
+    def constantize(camel_cased_word)
+      begin
+        names = camel_cased_word.split('::')
+        names.shift if names.empty? || names.first.empty?
+
+        constant = Object
+        names.each do |name|
+          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+        end
+        constant
+      rescue NameError
+        require underscore(camel_cased_word)
+        retry
+      end
+    end
+
+    # Snagged from active_support
+    def underscore(camel_cased_word)
+      camel_cased_word.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end

data/lib/cucumber/feature_file.rb

@@ -1,4 +1,4 @@
-require 'cucumber/parser/i18n/language'
+require 'cucumber/parser/natural_language'
 require 'cucumber/filter'
 
 module Cucumber
@@ -20,9 +20,9 @@ module Cucumber
     # Parses a file and returns a Cucumber::Ast
     # If +options+ contains tags, the result will
     # be filtered.
-    def parse(options={})
+    def parse(step_mother, options)
       filter = Filter.new(@lines, options)
-      language = Parser::I18n::Language[lang || options[:lang] || 'en']
+      language = Parser::NaturalLanguage.get(step_mother, (lang || options[:lang] || 'en'))
       language.parse(source, @path, filter)
     end
     

data/lib/cucumber/formatter/junit.rb

@@ -45,8 +45,8 @@ module Cucumber
       end
 
       def visit_scenario_name(keyword, name, file_colon_line, source_indent)
-        scenario_name = name.strip
-        scenario_name = "Unnamed scenario" if name == ""
+        scenario_name = name.strip.delete(".\r\n")
+        scenario_name = "Unnamed scenario" if name.blank?
         @scenario = scenario_name
         @outline = keyword.include?('Scenario Outline')
         @output = "Scenario#{ " outline" if @outline}: #{@scenario}\n\n"
@@ -96,16 +96,20 @@ module Cucumber
           @time += duration
           classname = "#{@feature_name}.#{@scenario}"
           name = "#{@scenario}#{suffix}"
-          @builder.testcase(:classname => classname, :name => name, :time => "%.6f" % duration) do
-            if status != :passed
-              @builder.failure(:message => "#{status.to_s} #{name}", :type => status.to_s) do
-                @builder.text! @output
-                @builder.text!(format_exception(exception)) if exception
+          failed = (status == :failed || (status == :pending && @options[:strict]))
+          #puts "FAILED:!!#{failed}"
+          if status == :passed || failed
+            @builder.testcase(:classname => classname, :name => name, :time => "%.6f" % duration) do
+              if failed
+                @builder.failure(:message => "#{status.to_s} #{name}", :type => status.to_s) do
+                  @builder.text! @output
+                  @builder.text!(format_exception(exception)) if exception
+                end
+                @failures += 1
               end
-              @failures += 1
             end
+            @tests += 1
           end
-          @tests += 1
         end
 
         def format_exception(exception)

data/lib/cucumber/formatter/pretty.rb

@@ -97,9 +97,9 @@ module Cucumber
       end
 
       def visit_examples_name(keyword, name)
-        names = name.empty? ? [name] : name.split("\n")
+        names = name.strip.empty? ? [name.strip] : name.split("\n")        
         @io.puts("\n    #{keyword} #{names[0]}")
-        names[1..-1].each {|s| @io.puts "      #{s}" }
+        names[1..-1].each {|s| @io.puts "      #{s}" } unless names.empty?
         @io.flush
         @indent = 6
         @scenario_indent = 6

data/lib/cucumber/language_support/hook_methods.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  module LanguageSupport
+    module HookMethods
+      def matches_tag_names?(other_tag_names)
+        tag_names.empty? || (tag_names.map{|tag| Ast::Tags.strip_prefix(tag)} & other_tag_names).any?
+      end
+    end
+  end
+end

data/lib/cucumber/language_support/language_methods.rb

@@ -0,0 +1,47 @@
+module Cucumber
+  module LanguageSupport
+    module LanguageMethods
+      def before(scenario)
+        step_mother.begin_scenario
+        execute_before(scenario)
+      end
+
+      def after(scenario)
+        execute_after(scenario)
+        step_mother.end_scenario
+      end
+
+      def execute_before(scenario)
+        step_mother.hooks_for(:before, scenario).each do |hook|
+          invoke(hook, 'Before', scenario, true)
+        end
+      end
+
+      def execute_after(scenario)
+        step_mother.hooks_for(:after, scenario).each do |hook|
+          invoke(hook, 'After', scenario, true)
+        end
+      end
+
+      def execute_after_step(scenario)
+        step_mother.hooks_for(:after_step, scenario).each do |hook|
+          invoke(hook, 'AfterStep', scenario, false)
+        end
+      end
+
+      private
+
+      def invoke(hook, location, scenario, exception_fails_scenario)
+        begin
+          hook.invoke(location, scenario)
+        rescue Exception => exception
+          if exception_fails_scenario
+            scenario.fail!(exception)
+          else
+            raise
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/language_support/step_definition_methods.rb

@@ -0,0 +1,44 @@
+module Cucumber
+  module LanguageSupport
+    module StepDefinitionMethods
+      def step_match(name_to_match, name_to_report)
+        if(match = regexp.match(name_to_match))
+          StepMatch.new(self, name_to_match, name_to_report, match.captures)
+        else
+          nil
+        end
+      end
+
+      # Formats the matched arguments of the associated Step. This method
+      # is usually called from visitors, which render output.
+      #
+      # The +format+ can either be a String or a Proc.
+      #
+      # If it is a String it should be a format string according to
+      # <tt>Kernel#sprinf</tt>, for example:
+      #
+      #   '<span class="param">%s</span></tt>'
+      #
+      # If it is a Proc, it should take one argument and return the formatted
+      # argument, for example:
+      #
+      #   lambda { |param| "[#{param}]" }
+      #
+      def format_args(step_name, format)
+        step_name.gzub(regexp, format)
+      end
+
+      def same_regexp?(regexp)
+        self.regexp == regexp
+      end
+
+      def backtrace_line
+        "#{file_colon_line}:in `#{regexp.inspect}'"
+      end
+
+      def text_length
+        regexp.inspect.jlength
+      end
+    end
+  end
+end

data/lib/cucumber/parser/natural_language.rb

@@ -0,0 +1,72 @@
+module Cucumber
+  module Parser
+    class NaturalLanguage
+      KEYWORD_KEYS = %w{name native encoding feature background scenario scenario_outline examples given when then but}
+
+      class << self
+        def get(step_mother, lang)
+          languages[lang] ||= new(step_mother, lang)
+        end
+
+        def languages
+          @languages ||= {}
+        end
+      end
+
+      def initialize(step_mother, lang)
+        @keywords = Cucumber::LANGUAGES[lang]
+        raise "Language not supported: #{lang.inspect}" if @keywords.nil?
+        @keywords['grammar_name'] = @keywords['name'].gsub(/\s/, '')
+        register_adverbs(step_mother) if step_mother
+      end
+
+      def register_adverbs(step_mother)
+        adverbs = %w{given when then and but}.map{|keyword| @keywords[keyword].split('|').map{|w| w.gsub(/\s/, '')}}.flatten
+        step_mother.register_adverbs(adverbs)
+      end
+
+      def parser
+        return @parser if @parser
+        i18n_tt = File.expand_path(File.dirname(__FILE__) + '/i18n.tt')
+        template = File.open(i18n_tt, Cucumber.file_mode('r')).read
+        erb = ERB.new(template)
+        grammar = erb.result(binding)
+        Treetop.load_from_string(grammar)
+        @parser = Parser::I18n.const_get("#{@keywords['grammar_name']}Parser").new
+        def @parser.inspect
+          "#<#{self.class.name}>"
+        end
+        @parser
+      end
+
+      def parse(source, path, filter)
+        feature = parser.parse_or_fail(source, path, filter)
+        feature.language = self if feature
+        feature
+      end
+
+      def keywords(key, raw=false)
+        return @keywords[key] if raw
+        return nil unless @keywords[key]
+        values = @keywords[key].split('|')
+        values.map{|value| "'#{value}'"}.join(" / ")
+      end
+
+      def incomplete?
+        KEYWORD_KEYS.detect{|key| @keywords[key].nil?}
+      end
+
+      def scenario_keyword
+        @keywords['scenario'].split('|')[0] + ':'
+      end
+
+      def but_keywords
+        @keywords['but'].split('|')
+      end
+
+      def and_keywords
+        @keywords['and'].split('|')
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -0,0 +1,73 @@
+require 'cucumber/rb_support/rb_hook'
+
+module Cucumber
+  module RbSupport
+    # This module defines the methods you can use to define pure Ruby
+    # Step Definitions and Hooks. This module is mixed into the toplevel
+    # object.
+    module RbDsl
+      class << self
+        attr_accessor :step_mother, :rb_language
+        
+        def alias_adverb(adverb)
+          alias_method adverb, :register_rb_step_definition
+        end
+      end
+
+      # Registers any number of +world_modules+ (Ruby Modules) and/or a Proc.
+      # The +proc+ will be executed once before each scenario to create an
+      # Object that the scenario's steps will run within. Any +world_modules+
+      # will be mixed into this Object (via Object#extend).
+      #
+      # This method is typically called from one or more Ruby scripts under 
+      # <tt>features/support</tt>. You can call this method as many times as you 
+      # like (to register more modules), but if you try to register more than 
+      # one Proc you will get an error.
+      #
+      # Cucumber will not yield anything to the +proc+. Examples:
+      #
+      #    World do
+      #      MyClass.new
+      #    end
+      #
+      #    World(MyModule)
+      #
+      def World(*world_modules, &proc)
+        RbDsl.rb_language.build_world_factory(*world_modules, &proc)
+      end
+
+      # Registers a Before proc. You can call this method as many times as you
+      # want (typically from ruby scripts under <tt>support</tt>).
+      def Before(*tag_names, &proc)
+        RbDsl.step_mother.register_hook(:before, RbHook.new(RbDsl.rb_language, tag_names, proc))
+      end
+
+      def After(*tag_names, &proc)
+        RbDsl.step_mother.register_hook(:after, RbHook.new(RbDsl.rb_language, tag_names, proc))
+      end
+
+      def AfterStep(*tag_names, &proc)
+        RbDsl.step_mother.register_hook(:after_step, RbHook.new(RbDsl.rb_language, tag_names, proc))
+      end
+
+      # Registers a new Ruby StepDefinition.
+      # This method is aliased
+      # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>, and
+      # also to the i18n translations whenever a feature of a
+      # new language is loaded.
+      #
+      # See Cucumber#alias_steps for details on how to
+      # create your own aliases.
+      #
+      # The +&proc+ gets executed in the context of a <tt>world</tt>
+      # object, which is defined by #World. A new <tt>world</tt>
+      # object is created for each scenario and is shared across
+      # step definitions within that scenario.
+      def register_rb_step_definition(regexp, &proc)
+        RbDsl.step_mother.register_step_definition(RbStepDefinition.new(RbDsl.rb_language, regexp, &proc))
+      end
+    end
+  end
+end
+
+extend(Cucumber::RbSupport::RbDsl)

data/lib/cucumber/rb_support/rb_hook.rb

@@ -0,0 +1,19 @@
+module Cucumber
+  module RbSupport
+    class RbHook
+      include LanguageSupport::HookMethods
+
+      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, scenario)
+        @rb_language.current_world.cucumber_instance_exec(false, location, scenario, &@proc)
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_language.rb

@@ -0,0 +1,129 @@
+require 'cucumber/rb_support/rb_dsl'
+require 'cucumber/rb_support/rb_step_definition'
+
+module Cucumber
+  module RbSupport
+    class NilWorld < StandardError
+      def initialize
+        super("World procs should never return nil")
+      end
+    end
+
+    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::StepMother#World RDoc\n"
+        message << "or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.\n\n"
+        super(message)
+      end
+    end
+
+    class RbLanguage
+      include LanguageSupport::LanguageMethods
+      attr_reader :current_world, :step_mother
+      
+      def initialize(step_mother)
+        @step_mother = step_mother
+        RbDsl.step_mother = step_mother
+        RbDsl.rb_language = self
+      end
+      
+      def load_step_def_file(step_def_file)
+        begin
+          require step_def_file
+        rescue LoadError => e
+          e.message << "\nFailed to load #{step_def_file}"
+          raise e
+        end
+      end
+      
+      def build_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 begin_scenario
+        create_world
+        extend_world
+        connect_world(@step_mother)
+      end
+
+      def end_scenario
+        @current_world = nil
+      end
+
+      def snippet_text(step_keyword, step_name, multiline_arg_class = nil)
+        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\nend"
+      end
+
+      def alias_adverbs(adverbs)
+        adverbs.each do |adverb|
+          RbDsl.alias_adverb(adverb)
+          World.alias_adverb(adverb)
+        end
+      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(World)
+        @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+        (@world_modules || []).each do |mod|
+          @current_world.extend(mod)
+        end
+      end
+
+      def connect_world(step_mother)
+        @current_world.__cucumber_step_mother = step_mother
+      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,56 @@
+require 'cucumber/step_match'
+require 'cucumber/core_ext/string'
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  # A 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 - for example:
+  #
+  #   Given /I have (\d+) cucumbers in my belly/ do
+  #     # some code here
+  #   end
+  #
+  class RbStepDefinition
+    include LanguageSupport::StepDefinitionMethods
+
+    class MissingProc < StandardError
+      def message
+        "Step definitions must always have a proc"
+      end
+    end
+
+    attr_reader :proc
+
+    def initialize(rb_language, pattern, &proc)
+      raise MissingProc if proc.nil?
+      if String === pattern
+        p = pattern.gsub(/\$\w+/, '(.*)') # Replace $var with (.*)
+        pattern = Regexp.new("^#{p}$") 
+      end
+      @rb_language, @regexp, @proc = rb_language, pattern, proc
+    end
+
+    def regexp
+      @regexp
+    end
+
+    def invoke(args)
+      args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
+      begin
+        @rb_language.current_world.cucumber_instance_exec(true, regexp.inspect, *args, &@proc)
+      rescue Cucumber::ArityMismatchError => e
+        e.backtrace.unshift(self.backtrace_line)
+        raise e
+      end
+    end
+
+    def file_colon_line
+      @proc.file_colon_line
+    end
+    
+    def file
+      @file ||= file_colon_line.split(':')[0]
+    end
+  end
+end

data/lib/cucumber/step_match.rb

@@ -10,10 +10,10 @@ module Cucumber
       @formatted_step_name
     end
 
-    def invoke(world, multiline_arg)
+    def invoke(multiline_arg)
       all_args = @args.dup
       all_args << multiline_arg if multiline_arg
-      @step_definition.invoke(world, all_args)
+      @step_definition.invoke(all_args)
     end
 
     def format_args(format = lambda{|a| a})