cucumber 0.3.101 → 0.3.102

data/features/usage.feature

@@ -116,14 +116,8 @@ Feature: Cucumber command line
        Given passing # features/sample.feature:12
       /^failing expectation$/    # features/step_definitions/sample_steps.rb:62
        Given failing expectation # features/failing_expectation.feature:4
-      /^I should transform ('\d+' to an Integer)$/   # features/step_definitions/sample_steps.rb:83
-       Then I should transform '10' to an Integer    # features/transform_sample.feature:4
-      /^I should transform ('\w+' to a Symbol)$/   # features/step_definitions/sample_steps.rb:87
-       Then I should transform 'abc' to a Symbol   # features/transform_sample.feature:7
       /^failing$/    # features/step_definitions/sample_steps.rb:8
        Given failing # features/sample.feature:18
-      /^I should not transform ('\d+') to an Integer$/   # features/step_definitions/sample_steps.rb:91
-       Then I should not transform '10' to an Integer    # features/transform_sample.feature:10
       (::) UNUSED (::)
       /^unused$/          # features/step_definitions/sample_steps.rb:66
       /^another unused$/  # features/step_definitions/sample_steps.rb:69

data/lib/cucumber/ast/feature.rb

@@ -26,6 +26,10 @@ module Cucumber
         end
       end
 
+      def source_tag_names
+        @tags.tag_names
+      end
+
       def accept_hook?(hook)
         @tags.accept_hook?(hook)
       end

data/lib/cucumber/ast/feature_element.rb

@@ -1,61 +1,68 @@
 require 'enumerator'
+require 'cucumber/ast/tags'
 
 module Cucumber
-  module FeatureElement #:nodoc:
-    attr_accessor :feature
+  module Ast
+    module FeatureElement #:nodoc:
+      attr_accessor :feature
 
-    def attach_steps(steps)
-      steps.each {|step| step.feature_element = self}
-    end
+      def attach_steps(steps)
+        steps.each {|step| step.feature_element = self}
+      end
 
-    def file_colon_line(line = @line)
-      @feature.file_colon_line(line) if @feature
-    end
+      def file_colon_line(line = @line)
+        @feature.file_colon_line(line) if @feature
+      end
 
-    def text_length
-      name_line_lengths.max
-    end
+      def text_length
+        name_line_lengths.max
+      end
 
-    def first_line_length
-      name_line_lengths[0]
-    end
+      def first_line_length
+        name_line_lengths[0]
+      end
 
-    def name_line_lengths
-      if @name.strip.empty?
-        [@keyword.jlength]
-      else
-        @name.split("\n").enum_for(:each_with_index).map do |line, line_number|
-          line_number == 0 ? @keyword.jlength + line.jlength : line.jlength + Ast::Step::INDENT - 1 # We -1 as names which are not keyword lines are missing a space between keyword and name
+      def name_line_lengths
+        if @name.strip.empty?
+          [@keyword.jlength]
+        else
+          @name.split("\n").enum_for(:each_with_index).map do |line, line_number|
+            line_number == 0 ? @keyword.jlength + line.jlength : line.jlength + Ast::Step::INDENT - 1 # We -1 as names which are not keyword lines are missing a space between keyword and name
+          end
         end
       end
-    end
 
-    def matches_scenario_names?(scenario_name_regexps)
-      scenario_name_regexps.detect{|name| name =~ @name}
-    end
+      def matches_scenario_names?(scenario_name_regexps)
+        scenario_name_regexps.detect{|name| name =~ @name}
+      end
 
-    def backtrace_line(name = "#{@keyword} #{@name}", line = @line)
-      @feature.backtrace_line(name, line) if @feature
-    end
+      def backtrace_line(name = "#{@keyword} #{@name}", line = @line)
+        @feature.backtrace_line(name, line) if @feature
+      end
 
-    def source_indent(text_length)
-      max_line_length - text_length
-    end
+      def source_indent(text_length)
+        max_line_length - text_length
+      end
 
-    def max_line_length
-      @steps.max_line_length(self)
-    end
+      def max_line_length
+        @steps.max_line_length(self)
+      end
 
-    def accept_hook?(hook)
-      @tags.accept_hook?(hook) || @feature.accept_hook?(hook)
-    end
+      def accept_hook?(hook)
+        Tags.matches?(source_tag_names, hook.tag_names)
+      end
 
-    def tag_count(tag)
-      @feature.tag_count(tag) == 0 ? @tags.count(tag) : @feature.tag_count(tag)
-    end
+      def source_tag_names
+        (@tags.tag_names + (@feature ? @feature.source_tag_names : [])).uniq
+      end
 
-    def language
-      @feature.language
+      def tag_count(tag)
+        @feature.tag_count(tag) == 0 ? @tags.count(tag) : @feature.tag_count(tag)
+      end
+
+      def language
+        @feature.language
+      end
     end
-   end
+  end
 end

data/lib/cucumber/ast/step_invocation.rb

@@ -163,4 +163,4 @@ module Cucumber
       end
     end
   end
-end
+end

data/lib/cucumber/ast/tags.rb

@@ -7,10 +7,32 @@ module Cucumber
     # This gets stored internally as <tt>["invoice", "release_2"]</tt>
     #
     class Tags #:nodoc:
-      def self.strip_prefix(tag_name)
-        tag_name =~ /^@(.*)/ ? $1 : tag_name
+      class << self
+        EXCLUDE_PATTERN = /^~/
+
+        def matches?(source_tag_names, tag_names)
+          exclude_tag_names, include_tag_names = tag_names.partition{|tag_name| exclude_tag?(tag_name)}
+          exclude_tag_names.map!{|name| name[1..-1]}
+          !excluded?(source_tag_names, exclude_tag_names) && included?(source_tag_names, include_tag_names)
+        end
+
+        def exclude_tag?(tag_name)
+          tag_name =~ EXCLUDE_PATTERN
+        end
+        
+        private
+        
+        def excluded?(source_tag_names, query_tag_names)
+          source_tag_names.any? && (source_tag_names & query_tag_names).any?
+        end
+        
+        def included?(source_tag_names, query_tag_names)
+          query_tag_names.empty? || (source_tag_names & query_tag_names).any?
+        end
       end
 
+      attr_reader :tag_names
+
       def initialize(line, tag_names)
         @line, @tag_names = line, tag_names
       end
@@ -23,7 +45,7 @@ module Cucumber
       end
 
       def accept_hook?(hook)
-        hook.tag_names.empty? || (hook.tag_names.map{|tag| Ast::Tags.strip_prefix(tag)} & @tag_names).any?
+        self.class.matches?(@tag_names, hook.tag_names)
       end
 
       def count(tag)

data/lib/cucumber/cli/drb_client.rb

@@ -13,7 +13,13 @@ module Cucumber
         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")
+        begin
+          DRb.start_service("druby://localhost:0")
+        rescue SocketError
+        # Ruby-1.8.7 on snow leopard doesn't like localhost:0 - but just :0
+        # seems to work just fine
+          DRb.start_service("druby://:0")
+        end
         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 }

data/lib/cucumber/cli/main.rb

@@ -8,6 +8,7 @@ require 'cucumber/formatter/color_io'
 require 'cucumber/cli/language_help_formatter'
 require 'cucumber/cli/configuration'
 require 'cucumber/cli/drb_client'
+require 'cucumber/ast/tags'
 
 module Cucumber
   module Cli
@@ -46,6 +47,7 @@ module Cucumber
         step_mother.after_configuration(configuration)
         features = step_mother.load_plain_text_features(configuration.feature_files)
         step_mother.load_code_files(configuration.step_defs_to_load)
+
         enable_diffing
 
         visitor = configuration.build_formatter_broadcaster(step_mother)
@@ -67,9 +69,9 @@ module Cucumber
 
       def exceeded_tag_limts?(features)
         exceeded = false
-        configuration.options[:include_tags].each do |tag, limit|
-          unless limit.nil?
-            tag_count = features.tag_count(tag)
+        configuration.options[:tag_names].each do |tag_name, limit|
+          if !Ast::Tags.exclude_tag?(tag_name) && limit
+            tag_count = features.tag_count(tag_name)
             if tag_count > limit.to_i
               exceeded = true
             end

data/lib/cucumber/cli/options.rb

@@ -20,8 +20,8 @@ module Cucumber
       max = BUILTIN_FORMATS.keys.map{|s| s.length}.max
       FORMAT_HELP = (BUILTIN_FORMATS.keys.sort.map do |key|
         "  #{key}#{' ' * (max - key.length)} : #{BUILTIN_FORMATS[key][1]}"
-      end) + ["Use --format rerun --out features.txt to rerun failing",
-        "failing features in a new run with cucumber @features.txt.",
+      end) + ["Use --format rerun --out features.txt to write out failing",
+        "features. You can rerun them with cucumber @features.txt.",
         "FORMAT can also be the fully qualified class name of",
         "your own custom formatter. If the class isn't loaded,",
         "Cucumber will attempt to require a file with a relative",
@@ -134,16 +134,14 @@ module Cucumber
           end
           opts.on("-t TAGS", "--tags TAGS",
             "Only execute the features or scenarios with the specified tags.",
-            "TAGS must be comma-separated without spaces. They can be",
-            "specified with or without the @ prefix. Example: --tags dev\n",
+            "TAGS must be comma-separated without spaces. Example: --tags @dev\n",
             "Negative tags: Prefix tags with ~ to exclude features or scenarios",
-            "having that tag.\n",
+            "having that tag. Example: --tags ~@slow\n",
             "Limit WIP: Positive tags can be given a threshold to limit the",
-            "number of occurrences. Example: --tags qa:3 will fail if there",
+            "number of occurrences. Example: --tags @qa:3 will fail if there",
             "are more than 3 occurrences of the @qa tag.") do |v|
-            include_tags, exclude_tags = *parse_tags(v)
-            @options[:include_tags].merge!(include_tags)
-            @options[:exclude_tags].merge!(exclude_tags)
+            tag_names = parse_tags(v)
+            @options[:tag_names].merge!(tag_names)
           end
           opts.on("-n NAME", "--name NAME",
             "Only execute the feature elements which match part of the given name.",
@@ -276,22 +274,15 @@ module Cucumber
 
       def parse_tags(tag_string)
         tag_names = tag_string.split(",")
-        excludes, includes = tag_names.partition{|tag| tag =~ /^~/}
-        excludes = excludes.map{|tag| tag[1..-1]}
-
-        # Strip @
-        includes = includes.map{|tag| Ast::Tags.strip_prefix(tag)}
-        excludes = excludes.map{|tag| Ast::Tags.strip_prefix(tag)}
-        [parse_tag_limits(includes), parse_tag_limits(excludes)]
+        parse_tag_limits(tag_names)
       end
  
-      def parse_tag_limits(includes)
-        dict = {}
-        includes.each do |tag|
+      def parse_tag_limits(tag_names)
+        tag_names.inject({}) do |dict, tag|
           tag, limit = tag.split(':')
           dict[tag] = limit.nil? ? limit : limit.to_i
+          dict
         end
-        dict
       end
 
       def disable_profile_loading?
@@ -328,8 +319,9 @@ module Cucumber
       def reverse_merge(other_options)
         @options = other_options.options.merge(@options)
         @options[:require] += other_options[:require]
-        @options[:include_tags].merge! other_options[:include_tags]
-        @options[:exclude_tags].merge! other_options[:exclude_tags]
+        @options[:excludes] += other_options[:excludes]
+        @options[:name_regexps] += other_options[:name_regexps]
+        @options[:tag_names].merge! other_options[:tag_names]
         @options[:env_vars] = other_options[:env_vars].merge(@options[:env_vars])
         if @options[:paths].empty?
           @options[:paths] = other_options[:paths]
@@ -381,8 +373,7 @@ module Cucumber
           :dry_run      => false,
           :formats      => [],
           :excludes     => [],
-          :include_tags => {},
-          :exclude_tags => {},
+          :tag_names    => {},
           :name_regexps => [],
           :env_vars     => {},
           :diff_enabled => true

data/lib/cucumber/constantize.rb

@@ -1,7 +1,9 @@
 module Cucumber
   module Constantize #:nodoc:
     def constantize(camel_cased_word)
+      try = 0
       begin
+        try += 1
         names = camel_cased_word.split('::')
         names.shift if names.empty? || names.first.empty?
 
@@ -10,9 +12,13 @@ module Cucumber
           constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
         end
         constant
-      rescue NameError
+      rescue NameError => e
         require underscore(camel_cased_word)
-        retry
+        if try < 2
+          retry
+        else
+          raise e
+        end
       end
     end
 

data/lib/cucumber/core_ext/instance_exec.rb

@@ -8,6 +8,7 @@ module Cucumber
 end
 
 class Object #:nodoc:
+  # TODO: Move most of this stuff out to an InstanceExecutor class.
   def cucumber_instance_exec(check_arity, pseudo_method, *args, &block)
     cucumber_run_with_backtrace_filtering(pseudo_method) do
       if check_arity && !cucumber_compatible_arity?(args, block)
@@ -21,7 +22,7 @@ class Object #:nodoc:
           )
         end
       else
-        instance_exec(*Cucumber::StepMother.transform_arguments(args), &block)
+        instance_exec(*args, &block)
       end
     end
   end

data/lib/cucumber/core_ext/string.rb

@@ -7,34 +7,24 @@ class String #:nodoc:
     end
   end
   
-  # re.source.gsub(/\([^)]*\)/, '$var')
-  # Cumulative #sub
-  def subs(re, *args)
-    args.inject(self) do |s,arg|
-      s.sub(re, arg)
-    end
-  end
-
-  # TODO: Use subs instead...
-  def gzub(regexp, format=nil, &proc)
-    md = match(regexp)
-    raise "#{self.inspect} doesn't match #{regexp.inspect}" if md.nil?
-    
+  # TODO: Move to StepMatch
+  # +groups+ is an array of 2-element arrays, where
+  # the 1st element is the value of a regexp match group,
+  # and the 2nd element is its start index.
+  def gzub(groups, format=nil, &proc)
     s = dup
-    pos = 0
-    md.captures.each_with_index do |m, n|
+    offset = 0
+    groups.each do |group|
       replacement = if block_given?
-        proc.call(m)
+        proc.call(group.val)
       elsif Proc === format
-        format.call(m)
+        format.call(group.val)
       else
-        format % m
+        format % group.val
       end
       
-      if md.offset(n+1)[0]
-        s[md.offset(n+1)[0] + pos, m.length] = replacement
-        pos += replacement.length - m.length
-      end
+      s[group.start + offset, group.val.length] = replacement
+      offset += replacement.length - group.val.length
     end
     s
   end

data/lib/cucumber/filter.rb

@@ -4,8 +4,7 @@ module Cucumber
     def initialize(lines, options)
       @lines = lines
 
-      @include_tags = options[:include_tags] ? options[:include_tags].keys : []
-      @exclude_tags = options[:exclude_tags] ? options[:exclude_tags].keys : []
+      @tag_names = options[:tag_names] ? options[:tag_names].keys : []
       @name_regexps = options[:name_regexps] || []
     end
 
@@ -29,18 +28,9 @@ module Cucumber
     end
 
     def matches_tags?(syntax_node)
-      !excluded_by_tags?(syntax_node) &&
-      included_by_tags?(syntax_node)
+      syntax_node.matches_tags?(@tag_names)
     end
 
-    def included_by_tags?(syntax_node)
-      @include_tags.empty? || syntax_node.has_all_tags?(@include_tags)
-    end
-
-    def excluded_by_tags?(syntax_node)
-      @exclude_tags.any? && syntax_node.has_tags?(@exclude_tags)
-    end
-    
     def outline_matches_names?(syntax_node)
       @name_regexps.nil? || @name_regexps.empty? || @name_regexps.detect{|name_regexp| syntax_node.outline_matches_name?(name_regexp)}
     end

data/lib/cucumber/formatter/console.rb

@@ -92,6 +92,8 @@ module Cucumber
         return unless options[:snippets]
         undefined = step_mother.steps(:undefined)
         return if undefined.empty?
+        
+        unknown_programming_language = step_mother.unknown_programming_language?
         snippets = undefined.map do |step|
           step_name = Undefined === step.exception ? step.exception.step_name : step.name
           step_multiline_class = step.multiline_arg ? step.multiline_arg.class : nil
@@ -101,8 +103,13 @@ module Cucumber
 
         text = "\nYou can implement step definitions for undefined steps with these snippets:\n\n"
         text += snippets.join("\n\n")
-
         @io.puts format_string(text, :undefined)
+
+        if unknown_programming_language
+          @io.puts format_string("\nIf you want snippets in a different programming language, just make sure a file\n" +
+                  "with the appropriate file extension exists where cucumber looks for step definitions.", :failed)
+        end
+
         @io.puts
         @io.flush
       end
@@ -119,23 +126,25 @@ module Cucumber
       end
 
       def print_tag_limit_warnings(options)
-        return unless tag_limit_breached?(options, @tag_occurences)
-        @io.puts
-        @io.puts format_string("Failed due to exceeding the tag limit", :failed)
-        options[:include_tags].each do |tag_name, limit|
-          tag_frequnecy = @tag_occurences[tag_name].size
-          if limit && tag_frequnecy > limit
-            @io.puts format_string("@#{tag_name} occurred:#{tag_frequnecy} limit:#{limit}", :failed)
-            @tag_occurences[tag_name].each {|location| @io.puts format_string("  #{location}", :failed)}
-            @io.flush
+        first_tag = true
+        options[:tag_names].each do |tag_name, limit|
+          unless Ast::Tags.exclude_tag?(tag_name)
+            tag_frequnecy = @tag_occurences[tag_name].size
+            if limit && tag_frequnecy > limit
+              @io.puts if first_tag
+              first_tag = false
+              @io.puts format_string("#{tag_name} occurred #{tag_frequnecy} times, but the limit was set to #{limit}", :failed)
+              @tag_occurences[tag_name].each {|location| @io.puts format_string("  #{location}", :failed)}
+              @io.flush
+            end
           end
         end
       end
 
       def record_tag_occurrences(feature_element, options)
         @tag_occurences ||= Hash.new{|k,v| k[v] = []}
-        options[:include_tags].each do |tag_name, limit|
-          if feature_element.tag_count(tag_name) > 0
+        options[:tag_names].each do |tag_name, limit|
+          if !Ast::Tags.exclude_tag?(tag_name) && feature_element.tag_count(tag_name) > 0
             @tag_occurences[tag_name] << feature_element.file_colon_line
           end
         end
@@ -171,15 +180,6 @@ module Cucumber
         raise "No format for #{key.inspect}: #{FORMATS.inspect}" if fmt.nil?
         fmt
       end
-
-      def tag_limit_breached?(options, tag_occurences)
-        return if tag_occurences.nil?
-        tag_limit_breached = false
-        options[:include_tags].each do |tag_name, limit|
-          tag_limit_breached ||= limit && (tag_occurences[tag_name].size > limit)
-        end
-        tag_limit_breached
-      end
     end
   end
 end