kosmas58-cucumber 0.3.102 → 0.3.103

data/lib/cucumber/formatter/profile.rb

@@ -12,13 +12,13 @@ module Cucumber
         @step_definition_durations = Hash.new { |h,step_definition| h[step_definition] = [] }
       end
 
-      def visit_step(step)
+      def step(step)
         @step_duration = Time.now
         @step = step
         super
       end
 
-      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+      def step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
         duration = Time.now - @step_duration
         super
 

data/lib/cucumber/formatter/progress.rb

@@ -3,33 +3,39 @@ require 'cucumber/formatter/console'
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format progress</tt>
-    class Progress < Ast::Visitor
+    class Progress
       include Console
+      attr_reader :step_mother
 
       def initialize(step_mother, io, options)
-        super(step_mother)
-        @io = io
-        @options = options
+        @step_mother, @io, @options = step_mother, io, options
       end
 
-      def visit_features(features)
-        super
+      def after_features(features)
         @io.puts
         @io.puts
         print_summary(features)
       end
 
-      def visit_feature_element(feature_element)
+      def before_feature_element(feature_element)
         record_tag_occurrences(feature_element, @options)
-        super
       end
 
-      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
         progress(status)
         @status = status
       end
+      
+      def before_outline_table(outline_table)
+        @outline_table = outline_table
+      end
+      
+      def after_outline_table(outline_table)
+        @outline_table = nil
+      end
 
-      def visit_table_cell_value(value, status)
+      def table_cell_value(value, status)
+        return unless @outline_table
         status ||= @status
         progress(status) unless table_header_cell?(status)
       end

data/lib/cucumber/formatter/rerun.rb

@@ -10,16 +10,15 @@ module Cucumber
     # This formatter is used by AutoTest - it will use the output to decide what
     # to run the next time, simply passing the output string on the command line.
     #
-    class Rerun < Ast::Visitor
+    class Rerun
       def initialize(step_mother, io, options)
-        super(step_mother)
         @io = io
         @options = options
         @file_names = []
         @file_colon_lines = Hash.new{|h,k| h[k] = []}
       end
 
-      def visit_features(features)
+      def features(features)
         super
         files = @file_names.uniq.map do |file|
           lines = @file_colon_lines[file]
@@ -28,7 +27,7 @@ module Cucumber
         @io.puts files.join(' ')
       end
 
-      def visit_feature_element(feature_element)
+      def feature_element(feature_element)
         @rerun = false
         super
         if @rerun
@@ -38,7 +37,7 @@ module Cucumber
         end
       end
 
-      def visit_step_name(keyword, step_match, status, source_indent, background)
+      def step_name(keyword, step_match, status, source_indent, background)
         @rerun = true if [:failed].index(status)
       end
     end

data/lib/cucumber/formatter/steps.rb

@@ -1,16 +1,15 @@
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format steps</tt>
-    class Steps < Ast::Visitor
+    class Steps
 
       def initialize(step_mother, io, options)
-        super(step_mother)
         @io = io
         @options = options
         @step_definition_files = collect_steps(step_mother)
       end
 
-      def visit_features(features)
+      def after_features(features)
         print_summary
       end
 

data/lib/cucumber/formatter/tag_cloud.rb

@@ -2,27 +2,28 @@ module Cucumber
   module Formatter
     # The formatter used for <tt>--format tag_cloud</tt>
     # Custom formatter that prints a tag cloud as a table.
-    class TagCloud < Cucumber::Ast::Visitor
+    class TagCloud
       def initialize(step_mother, io, options)
-        super(step_mother)
         @io = io
         @options = options
         @counts = Hash.new{|h,k| h[k] = 0}
       end
 
-      def visit_features(features)
-        super
+      def after_features(features)
         print_summary(features)
       end
 
-      def visit_tag_name(tag_name)
+      def tag_name(tag_name)
         @counts[tag_name] += 1
       end
+      
+      private
   
       def print_summary(features)
         matrix = @counts.to_a.sort{|paira, pairb| paira[0] <=> pairb[0]}.transpose
         table = Cucumber::Ast::Table.new(matrix)
-        Cucumber::Formatter::Pretty.new(@step_mother, @io, {}).visit_multiline_arg(table)
+        formatter = Cucumber::Formatter::Pretty.new(@step_mother, @io, {})
+        Cucumber::Ast::TreeWalker.new(@step_mother, [formatter], {}).visit_multiline_arg(table)
       end
     end
   end

data/lib/cucumber/formatter/usage.rb

@@ -3,11 +3,10 @@ require 'cucumber/formatter/progress'
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format usage</tt>
-    class Usage < Ast::Visitor
+    class Usage
       include Console
 
       def initialize(step_mother, io, options)
-        super(step_mother)
         @io = io
         @options = options
         @step_definitions = Hash.new { |h,step_definition| h[step_definition] = [] }
@@ -15,17 +14,15 @@ module Cucumber
         @locations = []
       end
 
-      def visit_features(features)
-        super
+      def after_features(features)
         print_summary(features)
       end
 
-      def visit_step(step)
+      def before_step(step)
         @step = step
-        super
       end
 
-      def visit_step_name(keyword, step_match, status, source_indent, background)
+      def step_name(keyword, step_match, status, source_indent, background)
         if step_match.step_definition
           location = @step.file_colon_line
           return if @locations.index(location)

data/lib/cucumber/language_support/step_definition_methods.rb

@@ -4,8 +4,8 @@ module Cucumber
   module LanguageSupport
     module StepDefinitionMethods
       def step_match(name_to_match, name_to_report)
-        if(groups = groups(name_to_match))
-          StepMatch.new(self, name_to_match, name_to_report, groups)
+        if(arguments = arguments_from(name_to_match))
+          StepMatch.new(self, name_to_match, name_to_report, arguments)
         else
           nil
         end

data/lib/cucumber/rb_support/rb_language.rb

@@ -3,6 +3,7 @@ require 'cucumber/rb_support/rb_world'
 require 'cucumber/rb_support/rb_step_definition'
 require 'cucumber/rb_support/rb_hook'
 require 'cucumber/rb_support/rb_transform'
+require 'cucumber/rb_support/regexp_argument_matcher'
 
 module Cucumber
   module RbSupport
@@ -55,6 +56,10 @@ module Cucumber
         end
       end
 
+      def arguments_from(regexp, step_name)
+        @regexp_argument_matcher.arguments_from(regexp, step_name)
+      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)

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -1,7 +1,7 @@
 require 'cucumber/step_match'
 require 'cucumber/core_ext/string'
 require 'cucumber/core_ext/proc'
-require 'cucumber/rb_support/rb_group'
+require 'cucumber/rb_support/regexp_argument_matcher'
 
 module Cucumber
   module RbSupport
@@ -41,8 +41,8 @@ module Cucumber
         regexp_source == step_definition.regexp_source
       end
 
-      def groups(step_name)
-        RbGroup.groups_from(@regexp, step_name)
+      def arguments_from(step_name)
+        RegexpArgumentMatcher.arguments_from(@regexp, step_name)
       end
 
       def invoke(args)

data/lib/cucumber/rb_support/regexp_argument_matcher.rb

@@ -0,0 +1,21 @@
+require 'cucumber/step_argument'
+
+module Cucumber
+  module RbSupport
+    class RegexpArgumentMatcher
+      def self.arguments_from(regexp, step_name)
+        match = regexp.match(step_name)
+        if match
+          n = 0
+          match.captures.map do |val|
+            n += 1
+            start = match.offset(n)[0]
+            StepArgument.new(val, start)
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/step_argument.rb

@@ -0,0 +1,9 @@
+module Cucumber
+  class StepArgument
+    attr_reader :val, :pos
+
+    def initialize(val, pos)
+      @val, @pos = val, pos
+    end
+  end
+end

data/lib/cucumber/step_match.rb

@@ -2,12 +2,12 @@ module Cucumber
   class StepMatch #:nodoc:
     attr_reader :step_definition
 
-    def initialize(step_definition, step_name, formatted_step_name, groups)
-      @step_definition, @step_name, @formatted_step_name, @groups = step_definition, step_name, formatted_step_name, groups
+    def initialize(step_definition, step_name, formatted_step_name, step_arguments)
+      @step_definition, @step_name, @formatted_step_name, @step_arguments = step_definition, step_name, formatted_step_name, step_arguments
     end
 
     def args
-      @groups.map{|g| g.val}
+      @step_arguments.map{|g| g.val}
     end
 
     def name
@@ -36,7 +36,7 @@ module Cucumber
     #   lambda { |param| "[#{param}]" }
     #
     def format_args(format = lambda{|a| a}, &proc)
-      @formatted_step_name || gzub(@step_name, @groups, format, &proc)
+      @formatted_step_name || replace_arguments(@step_name, @step_arguments, format, &proc)
     end
     
     def file_colon_line
@@ -51,23 +51,21 @@ module Cucumber
       @step_definition.text_length
     end
 
-    # +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(string, groups, format=nil, &proc)
+    def replace_arguments(string, step_arguments, format, &proc)
       s = string.dup
       offset = 0
-      groups.each do |group|
+      step_arguments.each do |step_argument|
+        next if step_argument.pos.nil?
         replacement = if block_given?
-          proc.call(group.val)
+          proc.call(step_argument.val)
         elsif Proc === format
-          format.call(group.val)
+          format.call(step_argument.val)
         else
-          format % group.val
+          format % step_argument.val
         end
 
-        s[group.start + offset, group.val.length] = replacement
-        offset += replacement.length - group.val.length
+        s[step_argument.pos + offset, step_argument.val.jlength] = replacement
+        offset += replacement.length - step_argument.val.jlength
       end
       s
     end

data/lib/cucumber/version.rb

@@ -2,7 +2,7 @@ module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
     MINOR = 3
-    TINY  = 102
+    TINY  = 103
     PATCH = nil # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')

data/spec/cucumber/ast/background_spec.rb

@@ -22,8 +22,7 @@ module Cucumber
 
         register
 
-        @visitor = Visitor.new(@step_mother)
-        @visitor.options = {}
+        @visitor = TreeWalker.new(@step_mother)
 
         @feature = mock('feature', :visit? => true).as_null_object
       end

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -57,14 +57,15 @@ module Cucumber
       end
 
       it "should replace all variables and call outline once for each table row" do
-        visitor = Visitor.new(@step_mother)
+        visitor = TreeWalker.new(@step_mother)
         visitor.should_receive(:visit_table_row).exactly(3).times
         visitor.visit_feature_element(@scenario_outline)
       end
 
       it "should pretty print" do
         require 'cucumber/formatter/pretty'
-        visitor = Formatter::Pretty.new(@step_mother, STDOUT, {:comment => true, :tag_names => {}})
+        formatter = Formatter::Pretty.new(@step_mother, STDOUT, {:comment => true, :tag_names => {}})
+        visitor = TreeWalker.new(@step_mother, [formatter])
         visitor.visit_feature_element(@scenario_outline)
       end
     end

data/spec/cucumber/ast/scenario_spec.rb

@@ -17,7 +17,7 @@ module Cucumber
         @dsl.Given /y is (\d+)/ do |n|
           $y = n.to_i
         end
-        @visitor = Visitor.new(@step_mother)
+        @visitor = TreeWalker.new(@step_mother)
         @visitor.options = {}
       end
 

data/spec/cucumber/formatter/html_spec.rb

@@ -1,16 +1,235 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'cucumber/formatter/html'
+require 'nokogiri'
+require 'cucumber/rb_support/rb_language'
 
 module Cucumber
   module Formatter
+    module SpecHelperDsl
+      attr_reader :feature_content, :step_defs
+      
+      def define_feature(string)
+        @feature_content = string
+      end
+      
+      def define_steps(&block)
+        @step_defs = block
+      end
+    end
+    module SpecHelper
+      def load_features(content)
+        feature_file = FeatureFile.new(nil, content)
+        features = Ast::Features.new
+        features.add_feature feature_file.parse(@step_mother, {})
+        features
+      end
+      
+      def run(features)
+        # options = { :verbose => true }
+        options = {}
+        tree_walker = Cucumber::Ast::TreeWalker.new(@step_mother, [@formatter], options, STDOUT)
+        tree_walker.visit_features(features)
+      end
+      
+      def define_steps
+        return unless step_defs = self.class.step_defs
+        rb = @step_mother.load_programming_language('rb')
+        dsl = Object.new 
+        dsl.extend RbSupport::RbDsl
+        dsl.instance_exec &step_defs
+        @step_mother.register_step_definitions(rb.step_definitions)
+      end
+      
+      Spec::Matchers.define :have_css_node do |css, regexp|
+        match do |doc|
+          nodes = doc.css(css)
+          nodes.detect{ |node| node.text =~ regexp }
+        end
+      end
+    end
+    
     describe Html do
       before(:each) do
         @out = StringIO.new
-        @html = Html.new(mock("step mother"), @out, {})
+        @formatter = Html.new(mock("step mother"), @out, {})
+        @step_mother = StepMother.new
       end
+      
+      extend SpecHelperDsl
+      include SpecHelper
 
       it "should not raise an error when visiting a blank feature name" do
-        lambda { @html.visit_feature_name("") }.should_not raise_error
+        lambda { @formatter.feature_name("") }.should_not raise_error
+      end
+      
+      describe "given a single feature" do
+        before(:each) do
+          features = load_features(self.class.feature_content || raise("No feature content defined!"))
+          define_steps
+          run(features)
+          @doc = Nokogiri.HTML(@out.string)
+        end
+        
+        describe "with a comment" do
+          define_feature <<-FEATURE
+            # Healthy
+          FEATURE
+          
+          it { @out.string.should =~ /^\<!DOCTYPE/ }
+          it { @out.string.should =~ /\<\/html\>$/ }
+          it { @doc.should have_css_node('.feature .comment', /Healthy/) }
+        end
+        
+        describe "with a tag" do
+          define_feature <<-FEATURE
+            @foo
+          FEATURE
+
+          it { @doc.should have_css_node('.feature .tag', /foo/) }
+        end
+        
+        describe "with a narrative" do
+          define_feature <<-FEATURE
+            Feature: Bananas
+              In order to find my inner monkey
+              As a human
+              I must eat bananas
+          FEATURE
+
+          it { @doc.should have_css_node('.feature h2', /Bananas/) }
+          it { @doc.should have_css_node('.feature .narrative', /must eat bananas/) }
+        end
+        
+        describe "with a background" do
+          define_feature <<-FEATURE
+            Feature: Bananas
+            
+            Background:
+              Given there are bananas
+          FEATURE
+
+          it { @doc.should have_css_node('.feature .background', /there are bananas/) }
+        end
+        
+        describe "with a scenario" do
+          define_feature <<-FEATURE
+            Scenario: Monkey eats banana
+              Given there are bananas
+          FEATURE
+
+          it { @doc.should have_css_node('.feature h3', /Monkey eats banana/) }
+          it { @doc.should have_css_node('.feature .scenario .step', /there are bananas/) }
+        end
+        
+        describe "with a scenario outline" do
+          define_feature <<-FEATURE
+            Scenario Outline: Monkey eats a balanced diet
+              Given there are <Things>
+            
+              Examples: Fruit
+               | Things  |
+               | apples  |
+               | bananas |
+              Examples: Vegetables
+               | Things   |
+               | broccoli |
+               | carrots  |
+          FEATURE
+          
+          it { @doc.should have_css_node('.feature .scenario.outline h4', /Fruit/) }
+          it { @doc.should have_css_node('.feature .scenario.outline h4', /Vegetables/) }
+          it { @doc.css('.feature .scenario.outline h4').length.should == 2}
+          it { @doc.should have_css_node('.feature .scenario.outline table', //) }
+          it { @doc.should have_css_node('.feature .scenario.outline table td', /carrots/) }
+        end
+        
+        describe "with a step with a py string" do
+          define_feature <<-FEATURE
+            Scenario: Monkey goes to town
+              Given there is a monkey called:
+               """
+               foo
+               """
+          FEATURE
+          
+          it { @doc.should have_css_node('.feature .scenario .val', /foo/) }
+        end
+
+        describe "with a multiline step arg" do
+          define_feature <<-FEATURE
+            Scenario: Monkey goes to town
+              Given there are monkeys:
+               | name |
+               | foo  |
+               | bar  |
+          FEATURE
+          
+          it { @doc.should have_css_node('.feature .scenario table td', /foo/) }
+        end
+        
+        describe "with a table in the background and the scenario" do
+          define_feature <<-FEATURE
+            Background:
+              Given table:
+                | a | b |
+                | c | d |
+            Scenario:
+              Given another table:
+               | e | f |
+               | g | h |
+          FEATURE
+          
+          it { @doc.css('td').length.should == 8 }
+        end
+        
+        describe "with a py string in the background and the scenario" do
+          define_feature <<-FEATURE
+            Background:
+              Given stuff:
+                """
+                foo
+                """
+            Scenario:
+              Given more stuff:
+                """
+                bar
+                """
+          FEATURE
+
+          it { @doc.css('.feature .background pre.val').length.should == 1 }
+          it { @doc.css('.feature .scenario pre.val').length.should == 1 }
+        end
+        
+        describe "with a step that fails in the scenario" do
+          define_steps do
+            Given(/boo/) { raise 'eek' }
+          end
+          
+          define_feature(<<-FEATURE)
+            Scenario: Monkey gets a fright
+              Given boo
+            FEATURE
+        
+          it { @doc.should have_css_node('.feature .scenario .step.failed', /eek/) }
+        end
+        
+        describe "with a step that fails in the backgound" do
+          define_steps do
+            Given(/boo/) { raise 'eek' }
+          end
+          
+          define_feature(<<-FEATURE)
+            Background:
+              Given boo
+            Scenario:
+              Given yay
+            FEATURE
+          
+          it { @doc.should have_css_node('.feature .background .step.failed', /eek/) }
+          it { @doc.should_not have_css_node('.feature .scenario .step.failed', //) }
+          it { @doc.should have_css_node('.feature .scenario .step.undefined', /yay/) }
+        end
+        
       end
     end
   end