cucumber 0.3.95 → 0.3.96

data/lib/cucumber/cli/drb_client.rb

@@ -7,14 +7,18 @@ module Cucumber
     end
     # Runs features on a DRB server, originally created with Spork compatibility in mind.
     class DRbClient
-      def self.run(args, error_stream, out_stream)
+      DEFAULT_PORT = 8990
+
+      def self.run(args, error_stream, out_stream, port = nil)
+        port ||= ENV["CUCUMBER_DRB"] || DEFAULT_PORT
+
         # See http://redmine.ruby-lang.org/issues/show/496 as to why we specify localhost:0
         DRb.start_service("druby://localhost:0")
-        feature_server = DRbObject.new_with_uri("druby://127.0.0.1:8990")
+        feature_server = DRbObject.new_with_uri("druby://127.0.0.1:#{port}")
         cloned_args = [] # I have no idea why this is needed, but if the regular args are sent then DRb magically transforms it into a DRb object - not an array
         args.each { |arg| cloned_args << arg }
         feature_server.run(cloned_args, error_stream, out_stream)
-      rescue DRb::DRbConnError
+      rescue DRb::DRbConnError => e
         raise DRbClientError, "No DRb server is running."
       end
     end

data/lib/cucumber/cli/language_help_formatter.rb

@@ -1,5 +1,5 @@
 require 'cucumber/formatter/pretty'
-require 'cucumber/parser/i18n/language'
+require 'cucumber/parser/natural_language'
 
 module Cucumber
   module Cli
@@ -23,8 +23,8 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
       end
 
       def self.list_keywords(io, lang)
-        language = Parser::I18n::Language[lang]
-        raw = Parser::I18n::Language::KEYWORD_KEYS.map do |key|
+        language = Parser::NaturalLanguage[lang]
+        raw = Parser::NaturalLanguage::KEYWORD_KEYS.map do |key|
           [key, language.keywords(key)]
         end
         table = Ast::Table.new(raw)
@@ -46,7 +46,7 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
       def visit_table_cell_value(value, status)
         if @col == 1
           if(@options[:check_lang])
-            @incomplete = Parser::I18n::Language[value].incomplete?
+            @incomplete = Parser::NaturalLanguage.get(nil, value).incomplete?
           end
           status = :comment 
         elsif @incomplete

data/lib/cucumber/cli/main.rb

@@ -15,17 +15,11 @@ module Cucumber
 
       class << self
         def step_mother
-          @step_mother
-        end
-
-        def step_mother=(step_mother)
-          @step_mother = step_mother
-          @step_mother.extend(StepMother)
-          @step_mother.snippet_generator = StepDefinition
+          @step_mother ||= StepMother.new
         end
 
         def execute(args)
-          new(args).execute!(@step_mother)
+          new(args).execute!(step_mother)
         end
       end
 
@@ -33,13 +27,15 @@ module Cucumber
         @args         = args
         @out_stream   = out_stream == STDOUT ? Formatter::ColorIO.new : out_stream
         @error_stream = error_stream
+        $err = error_stream
+        @unsupported_programming_languages = []
       end
 
       def execute!(step_mother)
         trap_interrupt
         if configuration.drb?
           begin
-            return DRbClient.run(@args, @error_stream, @out_stream)
+            return DRbClient.run(@args, @error_stream, @out_stream, configuration.drb_port)
           rescue DRbClientError => e
             @error_stream.puts "WARNING: #{e.message} Running features locally:"
           end
@@ -50,8 +46,8 @@ module Cucumber
         # This is because i18n step methods are only aliased when
         # features are loaded. If we swap the order, the requires
         # will fail.
-        features = load_plain_text_features
-        load_step_defs
+        features = load_plain_text_features(step_mother)
+        load_step_defs(step_mother)
         enable_diffing
 
         visitor = configuration.build_formatter_broadcaster(step_mother)
@@ -64,7 +60,7 @@ module Cucumber
             step_mother.scenarios(:passed).any?
           else
             step_mother.scenarios(:failed).any? ||
-            (configuration.strict? && step_mother.steps(:undefined).any?)
+            (configuration.strict? && (step_mother.steps(:undefined).any? || step_mother.steps(:pending).any?))
           end
       rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
         @error_stream.puts e.message
@@ -84,19 +80,19 @@ module Cucumber
         exceeded
       end
 
-      def load_plain_text_features
+      def load_plain_text_features(step_mother)
         features = Ast::Features.new
 
         verbose_log("Features:")
         configuration.feature_files.each do |f|
           feature_file = FeatureFile.new(f)
-          feature = feature_file.parse(configuration.options)
+          feature = feature_file.parse(step_mother, configuration.options)
           if feature
             features.add_feature(feature)
             verbose_log("  * #{f}")
           end
         end
-        verbose_log("\n"*2)
+        verbose_log("\n")
         features
       end
 
@@ -114,50 +110,36 @@ module Cucumber
 
       private
 
-      def load_step_defs
+      def load_step_defs(step_mother)
         step_def_files = configuration.step_defs_to_load
-        verbose_log("Step Definitions Files:")
+        verbose_log("Step Definitions:")
         step_def_files.each do |step_def_file|
-          load_step_def(step_def_file)
+          load_step_def(step_mother, step_def_file)
         end
+        verbose_log("\n")
       end
 
-      def load_step_def(step_def_file)
-        if loader = step_def_loader_for(step_def_file)
+      def load_step_def(step_mother, step_def_file)
+        if programming_language = programming_language_for(step_mother, step_def_file)
           verbose_log("  * #{step_def_file}")
-          loader.load_step_def_file(self, step_def_file)
+          programming_language.load_step_def_file(step_def_file)
+        else
+          verbose_log("  * #{step_def_file} [NOT SUPPORTED]")
         end
       end
 
-      def step_def_loader_for(step_def_file)
-        @sted_def_loaders ||= {}
+      def programming_language_for(step_mother, step_def_file) # :nodoc:
         if ext = File.extname(step_def_file)[1..-1]
-          loader = @sted_def_loaders[ext]
-          return nil if loader == :missing
-          return loader if loader
+          return nil if @unsupported_programming_languages.index(ext)
           begin
-            loader_class = configuration.constantize("Cucumber::Cli::#{ext.capitalize}StepDefLoader")
-            return @sted_def_loaders[ext] = loader_class.new
+            step_mother.load_programming_language(ext)
           rescue LoadError
-            @sted_def_loaders[ext] = :missing
+            @unsupported_programming_languages << ext
             nil
           end
+        else
+          nil
         end
-        nil
-      end
-
-      def step_def_files
-        main.verbose_log("Ruby files required:")
-        main.verbose_log(requires.map{|lib| "  * #{lib}"}.join("\n"))
-        requires.each do |lib|
-          begin
-            require lib
-          rescue LoadError => e
-            e.message << "\nFailed to load #{lib}"
-            raise e
-          end
-        end
-        main.verbose_log("\n")
       end
 
       def enable_diffing
@@ -186,5 +168,3 @@ module Cucumber
     end
   end
 end
-
-Cucumber::Cli::Main.step_mother = self

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