kosmas58-cucumber 0.1.99.23 → 0.1.100.5

data/lib/cucumber/ast/tags.rb

@@ -11,19 +11,12 @@ module Cucumber
         @line, @tag_names = line, tag_names
       end
 
-      def among?(tag_names)
-        no_tags, yes_tags = tag_names.partition{|tag| tag =~ /^~/}
-        no_tags = no_tags.map{|tag| tag[1..-1]}
-
-        # Strip @
-        yes_tags = yes_tags.map{|tag| tag =~ /^@(.*)/ ? $1 : tag}
-        no_tags = no_tags.map{|tag| tag =~ /^@(.*)/ ? $1 : tag}
-
-        (yes_tags.empty? || (@tag_names & yes_tags).any?) && (no_tags.empty? || (@tag_names & no_tags).empty?)
+      def has_tags?(tags)
+        (@tag_names & tags).any?
       end
 
-      def at_lines?(lines)
-        lines.empty? || lines.index(@line)
+      def matches_lines?(lines)
+        lines.index(@line)
       end
 
       def accept(visitor)

data/lib/cucumber/ast/visitor.rb

@@ -3,29 +3,35 @@ module Cucumber
     # A dumb visitor that implements the whole Visitor API and just walks the tree.
     class Visitor
       attr_accessor :options
+      attr_reader :step_mother
 
       def initialize(step_mother)
+        @options = {}
         @step_mother = step_mother
+        @current_feature_lines = []
       end
 
-      def world(scenario, world = nil, &proc)
-        @step_mother.world(scenario, world, &proc)
+      def current_feature_lines=(lines)
+        @current_feature_lines = lines
       end
 
-      def new_world
-        @step_mother.new_world
+      def matches_lines?(node)
+        @current_feature_lines.empty? || node.matches_lines?(@current_feature_lines)
       end
 
-      def step_definition(step_name)
-        @step_mother.step_definition(step_name)
+      def included_by_tags?(node)
+        tags = options[:include_tags] || []
+        tags.empty? || node.has_tags?(tags)
       end
 
-      def current_feature_lines=(lines)
-        @current_feature_lines = lines
+      def excluded_by_tags?(node)
+        tags = options[:exclude_tags] || []
+        tags.any? && node.has_tags?(tags)
       end
 
-      def current_feature_lines
-        @current_feature_lines || []
+      def matches_scenario_names?(node)
+        scenario_names = options[:scenario_names] || []
+        scenario_names.empty? || node.matches_scenario_names?(scenario_names)
       end
 
       def visit_features(features)
@@ -62,6 +68,9 @@ module Cucumber
         background.accept(self)
       end
 
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+      end
+
       def visit_examples(examples)
         examples.accept(self)
       end
@@ -70,10 +79,10 @@ module Cucumber
       end
 
       def visit_outline_table(outline_table)
-        outline_table.accept(self, nil)
+        outline_table.accept(self)
       end
 
-      def visit_scenario_name(keyword, name, file_line, source_indent)
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
       end
 
       def visit_steps(steps)
@@ -84,26 +93,33 @@ module Cucumber
         step.accept(self)
       end
 
-      def visit_step_name(keyword, step_name, status, step_definition, source_indent)
+      def visit_step_name(keyword, step_match, status, source_indent, background)
       end
 
-      def visit_multiline_arg(multiline_arg, status)
-        multiline_arg.accept(self, status)
+      def visit_multiline_arg(multiline_arg)
+        multiline_arg.accept(self)
       end
 
       def visit_py_string(string, status)
       end
 
-      def visit_table_row(table_row, status)
-        table_row.accept(self, status)
+      def visit_table_row(table_row)
+        table_row.accept(self)
       end
 
-      def visit_table_cell(table_cell, status)
-        table_cell.accept(self, status)
+      def visit_table_cell(table_cell)
+        table_cell.accept(self)
       end
 
       def visit_table_cell_value(value, width, status)
       end
+
+      def visit_exception(exception, status)
+      end
+
+      def announce(announcement)
+      end
+
     end
   end
 end

data/lib/cucumber/broadcaster.rb

@@ -1,15 +1,13 @@
 module Cucumber
   class Broadcaster
-
     def initialize(receivers = [])
       @receivers = receivers
     end
 
     def method_missing(method_name, *args)
-      @receivers.each  do |receiver|
+      @receivers.map do |receiver|
         receiver.__send__(method_name, *args)
       end
     end
-
   end
 end

data/lib/cucumber/cli/configuration.rb

@@ -74,9 +74,9 @@ module Cucumber
           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",
+            "exclude features or scenarios having that tag. Tags can be specified",
             "with or without the @ prefix.") do |v|
-            @options[:tags] = v.split(",")
+            @options[:include_tags], @options[:exclude_tags] = *parse_tags(v)
           end
           opts.on("-s SCENARIO", "--scenario SCENARIO", 
             "Only execute the scenario with the given name. If this option",
@@ -125,7 +125,7 @@ module Cucumber
           opts.on("-b", "--backtrace", "Show full backtrace for all errors.") do
             Exception.cucumber_full_backtrace = true
           end
-          opts.on("--strict", "Fail if there are any undefined steps.") do
+          opts.on("-S", "--strict", "Fail if there are any undefined steps.") do
             @options[:strict] = true
           end
           opts.on("-v", "--verbose", "Show the files and features loaded.") do
@@ -144,7 +144,7 @@ module Cucumber
             @out_stream.puts VERSION::STRING
             Kernel.exit
           end
-          opts.on_tail("--help", "You're looking at it.") do
+          opts.on_tail("-h", "--help", "You're looking at it.") do
             @out_stream.puts opts.help
             Kernel.exit
           end
@@ -159,10 +159,6 @@ module Cucumber
         @paths += args
       end
     
-      def ast_filter
-        Ast::Filter.new(@options)
-      end
-    
       def verbose?
         @options[:verbose]
       end
@@ -190,7 +186,18 @@ module Cucumber
           Cucumber.load_language(@options[:lang])
         end
       end
-    
+
+      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| tag =~ /^@(.*)/ ? $1 : tag}
+        excludes = excludes.map{|tag| tag =~ /^@(.*)/ ? $1 : tag}
+        [includes, excludes]
+      end
+
       def build_formatter_broadcaster(step_mother)
         return Formatter::Pretty.new(step_mother, nil, @options) if @options[:autoformat]
         formatters = @options[:formats].map do |format, out|
@@ -330,15 +337,16 @@ Defined profiles in cucumber.yml:
     
       def default_options
         {
-          :strict   => false,
-          :require  => nil,
-          :lang     => 'en',
-          :dry_run  => false,
-          :formats  => {},
-          :excludes => [],
-          :tags     => [],
+          :strict         => false,
+          :require        => nil,
+          :lang           => 'en',
+          :dry_run        => false,
+          :formats        => {},
+          :excludes       => [],
+          :include_tags   => [],
+          :exclude_tags   => [],
           :scenario_names => [],
-          :diff_enabled => true
+          :diff_enabled   => true
         }
       end
     

data/lib/cucumber/cli/language_help_formatter.rb

@@ -18,7 +18,7 @@ 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, :passed)
+        new(nil, io, {:check_lang=>true}, '').visit_multiline_arg(table)
       end
 
       def self.list_keywords(io, lang)
@@ -26,17 +26,17 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
           [key, Cucumber::LANGUAGES[lang][key]]
         end
         table = Ast::Table.new(raw)
-        new(nil, io, {:incomplete => Cucumber.language_incomplete?(lang)}, '').visit_multiline_arg(table, :passed)
+        new(nil, io, {:incomplete => Cucumber.language_incomplete?(lang)}, '').visit_multiline_arg(table)
       end
 
-      def visit_multiline_arg(table, status)
+      def visit_multiline_arg(table)
         if @options[:incomplete]
           @io.puts(format_string(INCOMPLETE, :failed))
         end
         super
       end
 
-      def visit_table_row(table_row, status)
+      def visit_table_row(table_row)
         @col = 1
         super
       end

data/lib/cucumber/cli/main.rb

@@ -44,9 +44,12 @@ module Cucumber
         features = load_plain_text_features
 
         visitor = configuration.build_formatter_broadcaster(step_mother)
+        step_mother.visitor = visitor # Needed to support World#announce
         visitor.visit_features(features)
-      
-        failure = features.steps[:failed].any? || (configuration.strict? && features.steps[:undefined].any?)
+
+        failure = step_mother.steps(:failed).any? || 
+          (configuration.strict? && step_mother.steps(:undefined).any?)
+
         Kernel.exit(failure ? 1 : 0)
       end
 
@@ -75,8 +78,7 @@ module Cucumber
       end
 
       def load_plain_text_features
-        filter = configuration.ast_filter
-        features = Ast::Features.new(filter)
+        features = Ast::Features.new
         parser = Parser::FeatureParser.new
 
         verbose_log("Features:")

data/lib/cucumber/core_ext/proc.rb

@@ -3,7 +3,7 @@ class Proc
   PROC_PATTERN = /[\d\w]+@(.*):(.*)>/
   
   if Proc.new{}.to_s =~ PROC_PATTERN
-    def to_backtrace_line(name)
+    def backtrace_line(name)
       "#{file_colon_line}:in `#{name}'"
     end
 
@@ -22,7 +22,7 @@ class Proc
     # This Ruby implementation doesn't implement Proc#to_s correctly
     STDERR.puts "*** THIS RUBY IMPLEMENTATION DOESN'T REPORT FILE AND LINE FOR PROCS ***"
     
-    def to_backtrace_line
+    def backtrace_line
       nil
     end
 

data/lib/cucumber/formatter/ansicolor.rb

@@ -70,7 +70,6 @@ module Cucumber
         'pending'   => 'yellow',
         'failed'    => 'red',
         'passed'    => 'green',
-        'thead'     => 'cyan',
         'outline'   => 'cyan',
         'skipped'   => 'cyan',
         'comment'   => 'grey',

data/lib/cucumber/formatter/console.rb

@@ -6,21 +6,16 @@ module Cucumber
       extend ANSIColor
       FORMATS = Hash.new{|hash, format| hash[format] = method(format).to_proc}
 
-      def format_step(keyword, step_name, status, step_definition, source_indent)
-        comment = if source_indent && step_definition
-          c = (' # ' + step_definition.file_colon_line).indent(source_indent)
+      def format_step(keyword, step_match, status, source_indent)
+        comment = if source_indent
+          c = (' # ' + step_match.file_colon_line).indent(source_indent)
           format_string(c, :comment)
         else
           ''
         end
 
-        begin
-          line = keyword + " " + step_definition.format_args(step_name, format_for(status, :param)) + comment
-        rescue
-          # It didn't match. This often happens for :outline steps
-          line = keyword + " " + step_name + comment
-        end
-
+        format = format_for(status, :param)
+        line = keyword + " " + step_match.format_args(format) + comment
         format_string(line, status)
       end
 
@@ -33,13 +28,8 @@ module Cucumber
         end
       end
 
-      def print_undefined_scenarios(features)
-        elements = features.scenarios.select{|scenario| scenario.undefined?}
-        print_elements(elements, :undefined, 'scenarios')
-      end
-
-      def print_steps(features, status)
-        print_elements(features.steps[status], status, 'steps')
+      def print_steps(status)
+        print_elements(step_mother.steps(status), status, 'steps')
       end
 
       def print_elements(elements, status, kind)
@@ -51,7 +41,7 @@ module Cucumber
 
         elements.each_with_index do |element, i|
           if status == :failed
-            print_exception(element.exception, 0)
+            print_exception(element.exception, status, 0)
           else
             @io.puts(format_string(element.backtrace_line, status))
           end
@@ -60,26 +50,27 @@ module Cucumber
         end
       end
 
-      def print_counts(features)
-        @io.puts dump_count(features.scenarios.length, "scenario")
+      def print_counts
+        @io.puts dump_count(step_mother.scenarios.length, "scenario")
 
         [:failed, :skipped, :undefined, :pending, :passed].each do |status|
-          if features.steps[status].any?
-            count_string = dump_count(features.steps[status].length, "step", status.to_s)
+          if step_mother.steps(status).any?
+            count_string = dump_count(step_mother.steps(status).length, "step", status.to_s)
             @io.puts format_string(count_string, status)
             @io.flush
           end
         end
       end
 
-      def print_exception(e, indent)
-        status = Cucumber::EXCEPTION_STATUS[e.class]
-        @io.puts(format_string("#{e.message} (#{e.class})\n#{e.backtrace.join("\n")}".indent(indent), status))
+      def print_exception(e, status, indent)
+        if @options[:strict] || !(Undefined === e) || e.nested?
+          @io.puts(format_string("#{e.message} (#{e.class})\n#{e.backtrace.join("\n")}".indent(indent), status))
+        end
       end
 
-      def print_snippets(features, options)
+      def print_snippets(options)
         return unless options[:snippets]
-        undefined = features.steps[:undefined]
+        undefined = step_mother.steps(:undefined)
         return if undefined.empty?
         snippets = undefined.map do |step|
           step_name = Undefined === step.exception ? step.exception.step_name : step.name
@@ -95,15 +86,14 @@ module Cucumber
         @io.flush
       end
 
-    private
-
-      def with_color
-        c = Term::ANSIColor.coloring?
-        Term::ANSIColor.coloring = @io.tty?
-        yield
-        Term::ANSIColor.coloring = c
+      def announce(announcement)
+        @io.puts
+        @io.puts(format_string(announcement, :tag))
+        @io.flush
       end
 
+    private
+
       def dump_count(count, what, state=nil)
         [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
       end

data/lib/cucumber/formatter/html.rb

@@ -54,12 +54,14 @@ module Cucumber
 
       def visit_background(background)
         @builder.div(:class => 'background') do
-          @builder.ol do
-            super
-          end
+          super
         end
       end
 
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+        @builder.h3("#{keyword} #{name}")
+      end
+
       def visit_feature_element(feature_element)
         @builder.div(:class => 'scenario') do
           super
@@ -67,7 +69,7 @@ module Cucumber
         @open_step_list = true
       end
       
-      def visit_scenario_name(keyword, name, file_line, source_indent)
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
         @builder.h3("#{keyword} #{name}")
       end
 
@@ -87,25 +89,26 @@ module Cucumber
         end
       end
 
-      def visit_step_name(keyword, step_name, status, step_definition, source_indent)
+      def visit_step_name(keyword, step_match, status, source_indent, background)
+        step_name = step_match.format_args(lambda{|param| "<span>#{param}</span>"})
         @builder.li("#{keyword} #{step_name}", :class => status)
       end
 
-      def visit_multiline_arg(multiline_arg, status)
+      def visit_multiline_arg(multiline_arg)
         if Ast::Table === multiline_arg
           @builder.table do
-            super(multiline_arg, status)
+            super
           end
         else
           @builder.p do
-            super(multiline_arg, status)
+            super
           end
         end
       end
 
-      def visit_table_row(table_row, status)
+      def visit_table_row(table_row)
         @builder.tr do
-          super(table_row, status)
+          super
         end
       end
 
@@ -113,6 +116,10 @@ module Cucumber
         @builder.td(value, :class => status)
       end
 
+      def announce(announcement)
+        @builder.pre(announcement, :class => 'announcement')
+      end
+
       private
 
       def inline_css
@@ -123,4 +130,4 @@ module Cucumber
 
     end
   end
-end
+end