cucumber 0.3.11 → 0.3.90

data/lib/cucumber/ast/visitor.rb

@@ -64,6 +64,7 @@ module Cucumber
       end
 
       def visit_outline_table(outline_table)
+        @table = outline_table
         outline_table.accept(self)
       end
 
@@ -105,7 +106,7 @@ module Cucumber
         table_cell.accept(self)
       end
 
-      def visit_table_cell_value(value, width, status)
+      def visit_table_cell_value(value, status)
       end
 
       def announce(announcement)

data/lib/cucumber/cli/configuration.rb

@@ -4,15 +4,16 @@ module Cucumber
 
     class Configuration
       BUILTIN_FORMATS = {
-        'html'     => 'Cucumber::Formatter::Html',
-        'pretty'   => 'Cucumber::Formatter::Pretty',
-        'profile'  => 'Cucumber::Formatter::Profile',
-        'progress' => 'Cucumber::Formatter::Progress',
-        'rerun'    => 'Cucumber::Formatter::Rerun',
-        'usage'    => 'Cucumber::Formatter::Usage',
-        'junit'    => 'Cucumber::Formatter::Junit'
+        'html'      => 'Cucumber::Formatter::Html',
+        'pretty'    => 'Cucumber::Formatter::Pretty',
+        'profile'   => 'Cucumber::Formatter::Profile',
+        'progress'  => 'Cucumber::Formatter::Progress',
+        'rerun'     => 'Cucumber::Formatter::Rerun',
+        'usage'     => 'Cucumber::Formatter::Usage',
+        'junit'     => 'Cucumber::Formatter::Junit',
+        'tag_cloud' => 'Cucumber::Formatter::TagCloud',
+        'steps'     => 'Cucumber::Formatter::Steps'
       }
-      DEFAULT_FORMAT = 'pretty'
       DRB_FLAG = '--drb'
       PROFILE_SHORT_FLAG = '-p'
       PROFILE_LONG_FLAG = '--profile'
@@ -26,15 +27,21 @@ module Cucumber
 
         @paths          = []
         @options        = default_options
-
-        @active_format  = DEFAULT_FORMAT
       end
 
       def parse!(args)
-        @args = args.empty? ? args_from_profile('default') : args
+        args.concat(%w{--profile default}) if args.empty?
+        @args = args
         expand_profiles_into_args
         return if parse_drb
 
+        @args.each do |arg|
+          if arg =~ /^(\w+)=(.*)$/
+            ENV[$1] = $2
+            @args.delete(arg)
+          end
+        end
+
         @args.extend(::OptionParser::Arguable)
 
         @args.options do |opts|
@@ -69,7 +76,7 @@ module Cucumber
             end
           end
           opts.on("-f FORMAT", "--format FORMAT",
-            "How to format features (Default: #{DEFAULT_FORMAT})",
+            "How to format features (Default: pretty)",
             "Available formats: #{BUILTIN_FORMATS.keys.sort.join(", ")}",
             "FORMAT can also be the fully qualified class name of",
             "your own custom formatter. If the class isn't loaded,",
@@ -79,7 +86,7 @@ module Cucumber
             "foo/bar_zap.rb. You can place the file with this relative",
             "path underneath your features/support directory or anywhere",
             "on Ruby's LOAD_PATH, for example in a Ruby gem.") do |v|
-            @options[:formats][v] = @out_stream
+            @options[:formats] << [v, @out_stream]
             @active_format = v
           end
           opts.on("-o", "--out [FILE|DIR]",
@@ -87,14 +94,17 @@ module Cucumber
             "applies to the previously specified --format, or the",
             "default format if no format is specified. Check the specific",
             "formatter's docs to see whether to pass a file or a dir.") do |v|
-            @options[:formats][@active_format] = v
+            @options[:formats] << ['pretty', nil] if @options[:formats].empty?
+            @options[:formats][-1][1] = v
           end
           opts.on("-t TAGS", "--tags TAGS",
             "Only execute the features or scenarios with the specified tags.",
             "TAGS must be comma-separated without spaces. Prefix tags with ~ to",
             "exclude features or scenarios having that tag. Tags can be specified",
             "with or without the @ prefix.") do |v|
-            @options[:include_tags], @options[:exclude_tags] = *parse_tags(v)
+            include_tags, exclude_tags = *parse_tags(v)
+            @options[:include_tags] += include_tags
+            @options[:exclude_tags] += exclude_tags
           end
           opts.on("-n NAME", "--name NAME",
             "Only execute the feature elements which match part of the given name.",
@@ -176,7 +186,7 @@ module Cucumber
           end
         end.parse!
 
-        @options[:formats]['pretty'] = @out_stream if @options[:formats].empty?
+        arrange_formats
 
         @options[:snippets] = true if !@quiet && @options[:snippets].nil?
         @options[:source]   = true if !@quiet && @options[:source].nil?
@@ -211,14 +221,6 @@ module Cucumber
         @drb
       end
 
-      def load_language
-        if Cucumber.language_incomplete?(@options[:lang])
-          list_keywords_and_exit(@options[:lang])
-        else
-          Cucumber.load_language(@options[:lang])
-        end
-      end
-
       def parse_tags(tag_string)
         tag_names = tag_string.split(",")
         excludes, includes = tag_names.partition{|tag| tag =~ /^~/}
@@ -232,7 +234,9 @@ module Cucumber
 
       def build_formatter_broadcaster(step_mother)
         return Formatter::Pretty.new(step_mother, nil, @options) if @options[:autoformat]
-        formatters = @options[:formats].map do |format, out|
+        formatters = @options[:formats].map do |format_and_out|
+          format = format_and_out[0]
+          out    = format_and_out[1]
           if String === out # file name
             unless File.directory?(out)
               out = File.open(out, Cucumber.file_mode('w'))
@@ -266,7 +270,7 @@ module Cucumber
       end
 
       def files_to_require
-        requires = @options[:require] || feature_dirs
+        requires = @options[:require] || require_dirs
         files = requires.map do |path|
           path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
           path = path.gsub(/\/$/, '') # Strip trailing slash.
@@ -292,6 +296,14 @@ module Cucumber
 
     protected
 
+      def arrange_formats
+        @options[:formats] << ['pretty', @out_stream] if @options[:formats].empty?
+        @options[:formats] = @options[:formats].sort_by{|f| f[1] == @out_stream ? -1 : 1}
+        if @options[:formats].length > 1 && @options[:formats][1][1] == @out_stream
+          raise "All but one formatter must use --out, only one can print to STDOUT"
+        end
+      end
+
       def remove_excluded_files_from(files)
         files.reject! {|path| @options[:excludes].detect {|pattern| path =~ pattern } }
       end
@@ -300,6 +312,10 @@ module Cucumber
         @paths.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
       end
 
+      def require_dirs
+        feature_dirs+Dir['vendor/{gems,plugins}/*/cucumber']
+      end
+
       def constantize(camel_cased_word)
         begin
           names = camel_cased_word.split('::')
@@ -377,6 +393,7 @@ Defined profiles in cucumber.yml:
         return @cucumber_yml
       end
 
+      # TODO: Move to Language
       def list_keywords_and_exit(lang)
         unless Cucumber::LANGUAGES[lang]
           raise("No language with key #{lang}")
@@ -398,9 +415,9 @@ Defined profiles in cucumber.yml:
         {
           :strict       => false,
           :require      => nil,
-          :lang         => 'en',
+          :lang         => nil,
           :dry_run      => false,
-          :formats      => {},
+          :formats      => [],
           :excludes     => [],
           :include_tags => [],
           :exclude_tags => [],

data/lib/cucumber/cli/drb_client.rb

@@ -3,18 +3,17 @@ require "drb/drb"
 
 module Cucumber
   module Cli
+    class DRbClientError < StandardError
+    end
     # Runs features on a DRB server, originally created with Spork compatibility in mind.
     class DRbClient
       def self.run(args, error_stream, out_stream)
-        begin
-          # 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.run(args, error_stream, out_stream)
-          true
-        rescue DRb::DRbConnError
-          false
-        end
+        # 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.run(args, error_stream, out_stream)
+      rescue DRb::DRbConnError
+        raise DRbClientError, "No DRb server is running."
       end
     end
   end

data/lib/cucumber/cli/language_help_formatter.rb

@@ -1,4 +1,5 @@
 require 'cucumber/formatter/pretty'
+require 'cucumber/parser/i18n/language'
 
 module Cucumber
   module Cli
@@ -18,15 +19,16 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
           [lang, Cucumber::LANGUAGES[lang]['name'], Cucumber::LANGUAGES[lang]['native']]
         end
         table = Ast::Table.new(raw)
-        new(nil, io, {:check_lang=>true}, '').visit_multiline_arg(table)
+        new(nil, io, {:check_lang=>true}).visit_multiline_arg(table)
       end
 
       def self.list_keywords(io, lang)
-        raw = Cucumber::KEYWORD_KEYS.map do |key|
-          [key, Cucumber::LANGUAGES[lang][key]]
+        language = Parser::I18n::Language[lang]
+        raw = Parser::I18n::Language::KEYWORD_KEYS.map do |key|
+          [key, language.keywords(key)]
         end
         table = Ast::Table.new(raw)
-        new(nil, io, {:incomplete => Cucumber.language_incomplete?(lang)}, '').visit_multiline_arg(table)
+        new(nil, io, {:incomplete => language.incomplete?}).visit_multiline_arg(table)
       end
 
       def visit_multiline_arg(table)
@@ -41,10 +43,10 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
         super
       end
 
-      def visit_table_cell_value(value, width, status)
+      def visit_table_cell_value(value, status)
         if @col == 1
           if(@options[:check_lang])
-            @incomplete = Cucumber.language_incomplete?(value)
+            @incomplete = Parser::I18n::Language[value].incomplete?
           end
           status = :comment 
         elsif @incomplete
@@ -52,7 +54,7 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
         end
         
         @col += 1
-        super(value, width, status)
+        super(value, status)
       end
     end
   end

data/lib/cucumber/cli/main.rb

@@ -2,6 +2,7 @@ require 'optparse'
 require 'cucumber'
 require 'ostruct'
 require 'cucumber/parser'
+require 'cucumber/feature_file'
 require 'cucumber/formatter/color_io'
 require 'cucumber/cli/language_help_formatter'
 require 'cucumber/cli/configuration'
@@ -34,20 +35,18 @@ module Cucumber
       
       def execute!(step_mother)
         if configuration.drb?
-          if DRbClient.run(@args, @error_stream, @out_stream)
-            return false
-          else
-            @error_stream.puts "WARNING: No DRb server is running. Running features locally:"
+          begin
+            return DRbClient.run(@args, @error_stream, @out_stream)
+          rescue DRbClientError => e
+            @error_stream.puts "WARNING: #{e.message} Running features locally:"
             configuration.parse!(@args)
           end
         end
-        configuration.load_language
         step_mother.options = configuration.options
 
+        features = load_plain_text_features
         require_files
         enable_diffing
-      
-        features = load_plain_text_features
 
         visitor = configuration.build_formatter_broadcaster(step_mother)
         step_mother.visitor = visitor # Needed to support World#announce
@@ -63,11 +62,11 @@ module Cucumber
 
       def load_plain_text_features
         features = Ast::Features.new
-        parser = Parser::FeatureParser.new
 
         verbose_log("Features:")
         configuration.feature_files.each do |f|
-          feature = parser.parse_file(f, configuration.options)
+          feature_file = FeatureFile.new(f)
+          feature = feature_file.parse(configuration.options)
           if feature
             features.add_feature(feature)
             verbose_log("  * #{f}")

data/lib/cucumber/feature_file.rb

@@ -0,0 +1,53 @@
+require 'cucumber/parser/i18n/language'
+require 'cucumber/filter'
+
+module Cucumber
+  class FeatureFile
+    FILE_COLON_LINE_PATTERN = /^([\w\W]*?):([\d:]+)$/
+    LANGUAGE_PATTERN = /language:\s*(.*)/
+
+    # The +uri+ argument can ba a path or a path:line1:line2 etc.
+    def initialize(uri, source=nil)
+      @source = source
+      _, @path, @lines = *FILE_COLON_LINE_PATTERN.match(uri)
+      if @path
+        @lines = @lines.split(':').map { |line| line.to_i }
+      else
+        @path = uri
+      end
+    end
+    
+    # Parses a file and returns a Cucumber::Ast
+    # If +options+ contains tags, the result will
+    # be filtered.
+    def parse(options={})
+      filter = Filter.new(@lines, options)
+      language = Parser::I18n::Language[lang || options[:lang] || 'en']
+      language.parse(source, @path, filter)
+    end
+    
+    def source
+      @source ||= if @path =~ /^http/
+        require 'open-uri'
+        open(@path).read
+      else
+        begin
+          File.open(@path, Cucumber.file_mode('r')).read 
+        rescue Errno::EACCES => e
+          p = File.expand_path(@path)
+          e.message << "\nCouldn't open #{p}"
+          raise e
+        end
+      end
+    end
+    
+    def lang
+      line_one = source.split(/\n/)[0]
+      if line_one =~ LANGUAGE_PATTERN
+        $1.strip
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/cucumber/filter.rb

@@ -0,0 +1,50 @@
+module Cucumber
+  class Filter
+    def initialize(lines, options)
+      @lines = lines
+      @include_tags = options[:include_tags] || []
+      @exclude_tags = options[:exclude_tags] || []
+      @name_regexps = options[:name_regexps] || []
+    end
+
+    def accept?(syntax_node)
+      at_line?(syntax_node) &&
+      matches_tags?(syntax_node) &&
+      matches_names?(syntax_node)
+    end
+
+    def accept_example?(syntax_node, outline)
+      (at_line?(syntax_node) || outline_at_line?(outline)) && 
+      (matches_names?(syntax_node) || outline_matches_names?(outline))
+    end
+    
+    def at_line?(syntax_node)
+      @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.at_line?(line)}
+    end
+
+    def outline_at_line?(syntax_node)
+       @lines.nil? || @lines.empty? || @lines.detect{|line| syntax_node.outline_at_line?(line)}
+    end
+
+    def matches_tags?(syntax_node)
+      !excluded_by_tags?(syntax_node) &&
+      included_by_tags?(syntax_node)
+    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
+    
+    def matches_names?(syntax_node)
+      @name_regexps.nil? || @name_regexps.empty? || @name_regexps.detect{|name_regexp| syntax_node.matches_name?(name_regexp)}
+    end
+  end
+end

data/lib/cucumber/formatter/console.rb

@@ -59,6 +59,18 @@ module Cucumber
       end
 
       def print_stats(features)
+        
+        @failures = step_mother.scenarios(:failed).select { |s| s.is_a?(Cucumber::Ast::Scenario) }
+        
+        if !@failures.empty?
+          @io.puts format_string("Failing Scenarios:", :failed)
+          @failures.each do |failure|
+            @io.puts format_string("cucumber " + failure.file_colon_line, :failed) +
+            format_string(" # Scenario: " + failure.name, :comment)
+          end
+          @io.puts
+        end
+        
         @io.print dump_count(step_mother.scenarios.length, "scenario")
         print_status_counts{|status| step_mother.scenarios(status)}
 

data/lib/cucumber/formatter/cucumber.css

@@ -1,53 +1,38 @@
+
+
 .cucumber {
-  background: black;
-  color: white;
+  font-family: "Lucida Grande", Helvetica, sans-serif;
+  font-size: 0.7em;
+  background: white;
   padding: 1em;
 }
-.cucumber .passed {
-  color: #008800;
-}
-.cucumber .undefined {
-  color: #888800;
+.cucumber h1, .cucumber h2, .cucumber h3, .cucumber h4, .cucumber ol, .cucumber li, .cucumber pre, .cucumber p {
+  font-size: 1em;
+  padding: 0px;
+  margin: 0px;
 }
-.cucumber .pending {
-  color: #888800;
+.cucumber div.feature {
+  border: 1px solid;
+  padding: 2px;
+  margin: 4px;
 }
-.cucumber .failed {
-  color: #880000;
+.cucumber div.feature div.background, .cucumber div.feature div.scenario, .cucumber div.feature p {
+  padding: 0em 0em 0em 1em;
 }
-.cucumber .skipped {
-  color: #008888;
-}
-.cucumber .outline {
-  color: #008888;
-}
-
-.cucumber .passed_param {
-  font-weight: bold;
-  color: #00ff00;
-}
-.cucumber .undefined_param {
-  font-weight: bold;
-  color: #ffff00;
-}
-.cucumber .pending_param {
-  font-weight: bold;
-  color: #ffff00;
+.cucumber div.feature div.background div.examples, .cucumber div.feature div.scenario div.examples, .cucumber div.feature p div.examples {
+  padding: 0em 0em 0em 1em;
 }
-.cucumber .failed_param {
-  font-weight: bold;
-  font-weight: bold;
-  color: #ff0000;
+.cucumber .stats {
+  margin: 2em;
 }
-.cucumber .skipped_param {
-  font-weight: bold;
-  color: #00ffff;
+.cucumber .summary ul.features li {
+  display: inline;
 }
-.cucumber .outline_param {
-  font-weight: bold;
-  color: #00ffff;
+.cucumber .backtrace {
+  margin-top: 0;
+  margin-bottom: 0;
+  margin-left: 1em;
 }
-
 .cucumber a {
   text-decoration: none;
   color: inherit;
@@ -58,17 +43,90 @@
 .cucumber a:visited {
   font-weight: normal;
 }
+.cucumber a div.examples {
+  border: 1px solid;
+  padding: 2px;
+  margin: 4px;
+}
+.cucumber table {
+  border-collapse: collapse;
+}
+.cucumber table td, .cucumber table th {
+  font-size: 0.7em;
+  border: 1px solid #AAAAAA;
+}
+.cucumber table td.failed {
+  background: #FFC0CB;
+  color: #8B0000;
+}
+.cucumber table td.passed {
+  background: #98FB98;
+  color: #001111;
+}
+.cucumber table td.skipped {
+  background: #e0ffff;
+  color: #001111;
+}
+.cucumber table td.pending {
+  background: #FFFFE0;
+  color: #111100;
+}
+.cucumber table td.undefined {
+  background: #FFFFE0;
+  color: #111100;
+}
 .cucumber ol {
   list-style: none;
 }
-.cucumber .stats {
-  margin: 2em;
+.cucumber ol li {
+  margin: 0em 0em 0em 1em;
+  padding: 0em 0em 0em 0.2em;
 }
-.cucumber .summary ul.features li {
-  display: inline;
+.cucumber ol li span.param {
+  font-weight: bold;
 }
-.cucumber .backtrace {
-  margin-top: 0;
-  margin-bottom: 0;
-  margin-left: 1em;
+.cucumber ol li.failed {
+  border-left: 5px solid #ff0000;
+  border-bottom: 1px solid #ff0000;
+  background: #ffc0cb;
+  color: #8b0000;
+}
+.cucumber ol li.failed span.param {
+  background: !failed_dark;
+}
+.cucumber ol li.passed {
+  border-left: 5px solid #00ff00;
+  border-bottom: 1px solid #00ff00;
+  background: #98fb98;
+  color: #001111;
+}
+.cucumber ol li.passed span.param {
+  background: #00ff00;
+}
+.cucumber ol li.skipped {
+  border-left: 5px solid #00ffff;
+  border-bottom: 1px solid #00ffff;
+  background: #e0ffff;
+  color: #001111;
+}
+.cucumber ol li.skipped span.param {
+  background: #00ffff;
+}
+.cucumber ol li.pending {
+  border-left: 5px solid #ff8000;
+  border-bottom: 1px solid #ff8000;
+  background: #ffff00;
+  color: #2a1b0a;
+}
+.cucumber ol li.pending span.param {
+  background: #ff8000;
+}
+.cucumber ol li.undefined {
+  border-left: 5px solid #ff8000;
+  border-bottom: 1px solid #ff8000;
+  background: #ffff00;
+  color: #2a1b0a;
+}
+.cucumber ol li.undefined span.param {
+  background: #ff8000;
 }