kosmas58-cucumber 0.3.11.6 → 0.3.90

data/lib/cucumber/formatter/pretty.rb

@@ -13,13 +13,13 @@ module Cucumber
       include Console
       attr_writer :indent
 
-      def initialize(step_mother, io, options, delim='|')
+      def initialize(step_mother, io, options)
         super(step_mother)
         @io = io
         @options = options
-        @delim = delim
         @exceptions = []
         @indent = 0
+        @prefixes = options[:prefixes] || {}
       end
 
       def visit_features(features)
@@ -145,6 +145,7 @@ module Cucumber
 
       def visit_multiline_arg(multiline_arg)
         return if @options[:no_multiline]
+        @table = multiline_arg
         super
       end
 
@@ -154,7 +155,8 @@ module Cucumber
       end
 
       def visit_table_row(table_row)
-        @io.print @delim.indent(@indent)
+        @col_index = 0
+        @io.print '  |'.indent(@indent-2)
         super
         @io.puts
         if table_row.exception && !@exceptions.index(table_row.exception)
@@ -169,13 +171,26 @@ module Cucumber
         @io.flush
       end
 
-      def visit_table_cell_value(value, width, status)
+      def visit_table_cell(cell)
+        super
+        @col_index += 1
+      end
+
+      def visit_table_cell_value(value, status)
         status ||= @status || :passed
-        @io.print(' ' + format_string((value.to_s || '').ljust(width), status) + ::Term::ANSIColor.reset(" #{@delim}"))
+        width = @table.col_width(@col_index)
+        cell_text = value.to_s || ''
+        padded = cell_text + (' ' * (width - cell_text.jlength))
+        prefix = cell_prefix(status)
+        @io.print(' ' + format_string("#{prefix}#{padded}", status) + ::Term::ANSIColor.reset(" |"))
         @io.flush
       end
 
       private
+      
+      def cell_prefix(status)
+        @prefixes[status]
+      end
 
       def print_summary(features)
         print_stats(features)

data/lib/cucumber/formatter/progress.rb

@@ -23,7 +23,7 @@ module Cucumber
         @status = status
       end
 
-      def visit_table_cell_value(value, width, status)
+      def visit_table_cell_value(value, status)
         status ||= @status
         progress(status) unless table_header_cell?(status)
       end

data/lib/cucumber/formatter/steps.rb

@@ -0,0 +1,49 @@
+module Cucumber
+  module Formatter
+    class Steps < Ast::Visitor
+
+      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)
+        print_summary
+      end
+
+      private
+
+      def print_summary
+        count = 0
+        @step_definition_files.keys.sort.each do |step_definition_file|
+          @io.puts step_definition_file
+          
+          sources = @step_definition_files[step_definition_file]
+          source_indent = source_indent(sources)
+          sources.sort.each do |file_colon_line, regexp|
+            @io.print "#{regexp}".indent(2)
+            @io.print " # #{file_colon_line}".indent(source_indent - regexp.size)
+            @io.puts
+          end
+          @io.puts
+          count += sources.size
+        end
+        @io.puts "#{count} step definition(s) in #{@step_definition_files.size} source file(s)."
+      end
+
+      def collect_steps(step_mother)
+        step_mother.step_definitions.inject({}) do |step_definitions, step_definition|
+          step_definitions[step_definition.file] ||= []
+          step_definitions[step_definition.file] << [ step_definition.file_colon_line, step_definition.regexp.inspect ]
+          step_definitions
+        end
+      end
+
+      def source_indent(sources)
+        sources.map { |file_colon_line, regexp| regexp.size }.max + 1
+      end
+    end
+  end
+end

data/lib/cucumber/parser/feature.rb

@@ -55,6 +55,10 @@ module Cucumber
         def has_tags?(tag_names)
           tags.has_tags?(tag_names)
         end
+
+        def has_all_tags?(tag_names)
+          tags.has_all_tags?(tag_names)
+        end
         
         def build(filter)
           if(filter.nil? || feature_elements.accept?(filter) || (!bg.empty? && filter.accept?(bg)))
@@ -211,6 +215,10 @@ module Cucumber
           ts.elements.detect{|e| e.tag.line == line}
         end
 
+        def has_all_tags?(tags)
+          (tags & tag_names) == tags
+        end
+
         def has_tags?(tags)
           (tag_names & tags).any?
         end
@@ -491,6 +499,11 @@ module Cucumber
           feature_tags.has_tags?(tag_names)
         end
 
+        def has_all_tags?(tag_names)
+          feature_tags = self.parent.tags
+          feature_tags.has_all_tags?(tag_names)
+        end
+
         def build
           Ast::Background.new(
             comment.build, 
@@ -688,6 +701,11 @@ module Cucumber
           tags.has_tags?(tag_names) || feature_tags.has_tags?(tag_names)
         end
 
+        def has_all_tags?(tag_names)
+          feature_tags = self.parent.parent.tags
+          tags.has_all_tags?(tag_names) || feature_tags.has_all_tags?(tag_names)
+        end
+
         def matches_name?(regexp_to_match)
           name.build =~ regexp_to_match
         end
@@ -826,6 +844,11 @@ module Cucumber
           tags.has_tags?(tag_names) || feature_tags.has_tags?(tag_names)
         end
 
+        def has_all_tags?(tag_names)
+          feature_tags = self.parent.parent.tags
+          tags.has_all_tags?(tag_names) || feature_tags.has_all_tags?(tag_names)
+        end
+
         def matches_name?(regexp_to_match)
           outline_matches_name?(regexp_to_match) || examples_sections.matches_name?(regexp_to_match)
         end
@@ -1162,6 +1185,10 @@ module Cucumber
           true
         end
 
+        def has_all_tags?(tag_names)
+          true
+        end
+
         def outline_at_line?(line)
           true
         end

data/lib/cucumber/parser/i18n/language.rb

@@ -0,0 +1,83 @@
+module Cucumber
+  module Parser
+    module I18n
+      class Language
+        KEYWORD_KEYS = %w{name native encoding feature background scenario scenario_outline examples given when then but}
+
+        class << self
+          LANGUAGES = Hash.new{|h,k| h[k] = Language.new(k)}
+          
+          def [](key)
+            LANGUAGES[key]
+          end
+
+          def alias_step_definitions(keywords) #:nodoc:
+            all_keywords = %w{given when then and but}.map{|keyword| keywords[keyword].split('|')}.flatten
+            alias_steps(all_keywords)
+          end
+
+          # Sets up additional method aliases for Given, When and Then.
+          # This does *not* affect how feature files are parsed. If you
+          # want to create aliases in the parser, you have to do this in
+          # languages.yml. For example:
+          #
+          # and: And|With
+          def alias_steps(keywords)
+            keywords.each do |adverb|
+              StepMother.alias_adverb(adverb)
+              World.alias_adverb(adverb)
+            end
+          end
+        end
+
+        alias_step_definitions(Cucumber::LANGUAGES['en'])
+
+        def initialize(lang)
+          @keywords = Cucumber::LANGUAGES[lang]
+          raise "Language not supported: #{lang.inspect}" if @keywords.nil?
+          @keywords['grammar_name'] = @keywords['name'].gsub(/\s/, '')
+        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)
+          self.class.alias_step_definitions(@keywords)
+          @parser = Parser::I18n.const_get("#{@keywords['grammar_name']}Parser").new
+        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
+end

data/lib/cucumber/rake/task.rb

@@ -194,6 +194,7 @@ module Cucumber
           result = []
           result += feature_list.to_a if feature_list
           result += FileList[feature_pattern].to_a if feature_pattern
+          result = make_command_line_safe(result)
           FileList[result]
         end
       end
@@ -208,6 +209,11 @@ module Cucumber
           FileList[result]
         end
       end
+
+      private
+      def make_command_line_safe(list)
+        list.map{|string| string.gsub(' ', '\ ')}
+      end
     end
 
     class FeatureTask < Task

data/lib/cucumber/step_match.rb

@@ -34,7 +34,7 @@ module Cucumber
   end
   
   class NoStepMatch
-    attr_reader :step_definition
+    attr_reader :step_definition, :name
 
     def initialize(step, name)
       @step = step

data/lib/cucumber/version.rb

@@ -2,8 +2,8 @@ module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
     MINOR = 3
-    TINY  = 11
-    PATCH = 6 # Set to nil for official release
+    TINY  = 90
+    PATCH = 1 # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
   end

data/lib/cucumber/webrat/table_locator.rb

@@ -0,0 +1,66 @@
+module Webrat
+  class Table < Element
+    def self.xpath_search
+      ".//table"
+    end
+
+    # Converts this Table element into a 2-dimensional array of String where each cell
+    # represents the inner_html of the <td> and <th> elements. The number of columns is
+    # determined by the number of cells in the first row.
+    def to_a
+      col_count = nil
+      Webrat::XML.css_search(@element, 'tr').map do |row|
+        cols = Webrat::XML.css_search(row, 'th,td')
+        col_count ||= cols.length
+        cols[0...col_count].map do |col|
+          col.inner_html
+        end
+      end
+    end
+  end
+  
+  module Locators
+    class TableLocator < Locator
+      def locate
+        Table.load(@session, table_element)
+      end
+
+      def table_element
+        table_elements.detect do |table_element|
+          matches_id?(table_element) ||
+          matches_css_selector?(table_element)
+        end
+      end
+
+      def matches_id?(table_element)
+        Webrat::XML.attribute(table_element, "id") == @value.to_s
+      end
+
+      def matches_css_selector?(table_element)
+        Webrat::XML.css_at(@dom, @value)
+      end
+
+      def table_elements
+        Webrat::XML.xpath_search(@dom, *Table.xpath_search)
+      end
+
+      def error_message
+        "Could not find table matching '#{@value}'"
+      end
+    end
+
+    # Returns a Table element located by +id_or_selector+, which can
+    # be a DOM id or a CSS selector.
+    def table_at(id_or_selector)
+      TableLocator.new(@session, dom, id_or_selector).locate!
+    end
+  end
+  
+  module Methods
+    delegate_to_session :table_at
+  end
+  
+  class Session
+    def_delegators :current_scope, :table_at
+  end
+end

data/rails_generators/cucumber/templates/en/webrat_steps.rb

@@ -98,6 +98,15 @@ Then /^I should see "([^\"]*)"$/ do |text|
 <% end -%>
 end
 
+Then /^I should see \/([^\/]*)\/$/ do |regexp|
+  regexp = Regexp.new(regexp)
+<% if framework == :rspec -%>
+  response.should contain(regexp)
+<% else -%>
+  assert_contain regexp
+<% end -%>
+end
+
 Then /^I should not see "([^\"]*)"$/ do |text|
 <% if framework == :rspec -%>
   response.should_not contain(text)
@@ -106,6 +115,14 @@ Then /^I should not see "([^\"]*)"$/ do |text|
 <% end -%>
 end
 
+Then /^I should not see \/([^\/]*)\/$/ do |regexp|
+<% if framework == :rspec -%>
+  response.should_not contain(text)
+<% else -%>
+  assert_not_contain text
+<% end -%>
+end
+
 Then /^the "([^\"]*)" field should contain "([^\"]*)"$/ do |field, value|
 <% if framework == :rspec -%>
   field_labeled(field).value.should =~ /#{value}/

data/rails_generators/cucumber/templates/env.rb

@@ -15,6 +15,7 @@ Cucumber::Rails.use_transactional_fixtures
 Cucumber::Rails.bypass_rescue
 
 require 'webrat'
+require 'cucumber/webrat/table_locator' # Lets you do table.diff!(table_at('#my_table').to_a)
 
 Webrat.configure do |config|
   config.mode = :rails

data/rails_generators/feature/templates/feature.erb

@@ -25,7 +25,7 @@ Feature: Manage <%= plural_name %>
 <% end -%>
     When I delete the 3rd <%= singular_name %>
     Then I should see the following <%= plural_name %>:
-      |<%= named_args.map(&:name).join('|') %>|
+      |<%= named_args.map{|arg| arg.name.humanize}.join('|') %>|
 <% [1,2,4].each do |n| -%>
       |<%= named_args.map{|arg| arg.value(n)}.join('|') %>|
 <% end -%>

data/rails_generators/feature/templates/steps.erb

@@ -9,12 +9,6 @@ When /^I delete the (\d+)(?:st|nd|rd|th) <%= singular_name %>$/ do |pos|
   end
 end
 
-Then /^I should see the following <%= plural_name %>:$/ do |<%= plural_name %>|
-  <%= plural_name %>.rows.each_with_index do |row, i|
-    row.each_with_index do |cell, j|
-      response.should have_selector("table > tr:nth-child(#{i+2}) > td:nth-child(#{j+1})") { |td|
-        td.inner_text.should == cell
-      }
-    end
-  end
+Then /^I should see the following <%= plural_name %>:$/ do |expected_<%= plural_name %>_table|
+  expected_<%= plural_name %>_table.diff!(table_at('table').to_a)
 end

data/spec/cucumber/ast/table_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'cucumber/ast/table'
 
@@ -168,6 +169,150 @@ module Cucumber
 
       end
       
+      describe "diff!" do
+        it "should detect a complex diff" do
+          t1 = table(%{
+            | 1         | 22          | 333         | 4444         |
+            | 55555     | 666666      | 7777777     | 88888888     |
+            | 999999999 | 0000000000  | 01010101010 | 121212121212 |
+            | 4000      | ABC         | DEF         | 50000        |
+          })
+          
+          t2 = table(%{
+            | a     | 4444     | 1         | 
+            | bb    | 88888888 | 55555     | 
+            | ccc   | xxxxxxxx | 999999999 | 
+            | dddd  | 4000     | 300       |
+            | e     | 50000    | 4000      |
+          })
+          lambda{t1.diff!(t2)}.should raise_error
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     1         | (-) 22         | (-) 333         |     4444         | (+) a    |
+            |     55555     | (-) 666666     | (-) 7777777     |     88888888     | (+) bb   |
+            | (-) 999999999 | (-) 0000000000 | (-) 01010101010 | (-) 121212121212 | (+)      |
+            | (+) 999999999 | (+)            | (+)             | (+) xxxxxxxx     | (+) ccc  |
+            | (+) 300       | (+)            | (+)             | (+) 4000         | (+) dddd |
+            |     4000      | (-) ABC        | (-) DEF         |     50000        | (+) e    |
+          }
+        end
+
+        it "should not change table when diffed with identical" do
+          t = table(%{
+            |a|b|c|
+            |d|e|f|
+            |g|h|i|
+          })
+          t.diff!(t.dup)
+          t.to_s(:indent => 12, :color => false).should == %{
+            |     a |     b |     c |
+            |     d |     e |     f |
+            |     g |     h |     i |
+          }
+        end
+
+        it "should inspect missing and surplus cells" do
+          t1 = Table.new([
+            ['name',  'male', 'lastname', 'swedish'],
+            ['aslak', 'true', 'hellesøy', 'false']
+          ])
+          t2 = Table.new([
+            ['name',  'male', 'lastname', 'swedish'],
+            ['aslak', true,   'hellesøy', false]
+          ])
+          lambda{t1.diff!(t2)}.should raise_error
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male       |     lastname |     swedish     |
+            | (-) aslak | (-) (i) "true" | (-) hellesøy | (-) (i) "false" |
+            | (+) aslak | (+) (i) true   | (+) hellesøy | (+) (i) false   |
+          }
+        end
+
+        it "should allow column mapping before diffing" do
+          t1 = Table.new([
+            ['name',  'male'],
+            ['aslak', 'true']
+          ])
+          t1.map_column!('male') { |m| m == 'true' }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.diff!(t2)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+
+        it "should allow header mapping before diffing" do
+          t1 = Table.new([
+            ['Name',  'Male'],
+            ['aslak', 'true']
+          ])
+          t1.map_headers!('Name' => 'name', 'Male' => 'male')
+          t1.map_column!('male') { |m| m == 'true' }
+          t2 = Table.new([
+            ['name',  'male'],
+            ['aslak', true]
+          ])
+          t1.diff!(t2)
+          t1.to_s(:indent => 12, :color => false).should == %{
+            |     name  |     male |
+            |     aslak |     true |
+          }
+        end
+        
+        describe "raising" do
+          before do
+            @t = table(%{
+              | a | b |
+              | c | d |
+            })
+          end
+          
+          it "should raise on missing rows" do
+            t = table(%{
+              | a | b |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :missing_row => false) }.should_not raise_error
+          end
+
+          it "should raise on surplus rows" do
+            t = table(%{
+              | a | b |
+              | c | d |
+              | e | f |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :surplus_row => false) }.should_not raise_error
+          end
+
+          it "should raise on missing columns" do
+            t = table(%{
+              | a |
+              | c |
+            })
+            lambda { @t.dup.diff!(t) }.should raise_error
+            lambda { @t.dup.diff!(t, :missing_col => false) }.should_not raise_error
+          end
+
+          it "should not raise on surplus columns" do
+            t = table(%{
+              | a | b | x |
+              | c | d | y |
+            })
+            lambda { @t.dup.diff!(t) }.should_not raise_error
+            lambda { @t.dup.diff!(t, :surplus_col => true) }.should raise_error
+          end
+        end
+
+        def table(text, file=nil, line_offset=0)
+          @table_parser ||= Parser::TableParser.new
+          @table_parser.parse_or_fail(text.strip, file, line_offset)
+        end
+      end
+      
       it "should convert to sexp" do
         @table.to_sexp.should == 
           [:table, 

data/spec/cucumber/cli/configuration_spec.rb

@@ -55,6 +55,19 @@ module Cli
       ]
     end
 
+    it "should require files in vendor/{plugins,gems}/*/cucumber/*.rb" do
+      given_the_following_files("/vendor/plugins/plugin_a/cucumber/foo.rb",
+                                "/vendor/gems/gem_a/cucumber/bar.rb")
+
+      config = Configuration.new(StringIO.new)
+      config.parse!(%w{--require /features})
+
+      config.files_to_require.should == [
+        "/vendor/plugins/plugin_a/cucumber/foo.rb",
+        "/vendor/gems/gem_a/cucumber/bar.rb"
+      ]
+    end
+
     describe "--exclude" do
 
       it "excludes a ruby file from requiring when the name matches exactly" do

data/spec/cucumber/cli/main_spec.rb

@@ -19,7 +19,6 @@ module Cucumber
 
         before(:each) do
           @empty_feature = Ast::Feature.new(nil, Ast::Comment.new(''), Ast::Tags.new(2, []), "Feature", [])
-          Dir.stub!(:[])
         end
 
         it "should show ruby files required" do

data/spec/cucumber/formatter/progress_spec.rb

@@ -17,7 +17,7 @@ module Cucumber
       describe "visiting a table cell value without a status" do
         it "should take the status from the last run step" do
           @progress.visit_step_result('', '', nil, :failed, nil, 10, nil)
-          @progress.visit_table_cell_value('value', 10, nil)
+          @progress.visit_table_cell_value('value', nil)
 
           @out.string.should == "FF"
         end
@@ -25,7 +25,7 @@ module Cucumber
 
       describe "visiting a table cell which is a table header" do
         it "should not output anything" do
-          @progress.visit_table_cell_value('value', 10, :skipped_param)
+          @progress.visit_table_cell_value('value', :skipped_param)
 
           @out.string.should == ""
         end