kosmas58-cucumber 0.3.11.6 → 0.3.90

data/lib/cucumber/ast/table.rb

@@ -7,7 +7,9 @@ module Cucumber
     #
     # This gets parsed into a Table holding the values <tt>[['a', 'b'], ['c', 'd']]</tt>
     #
-    class Table      
+    class Table
+      include Enumerable
+      
       NULL_CONVERSIONS = Hash.new(lambda{ |cell_value| cell_value }).freeze
 
       attr_accessor :file
@@ -16,18 +18,19 @@ module Cucumber
         "table"
       end
 
-      def initialize(raw, conversions = NULL_CONVERSIONS.dup)
-        # Verify that it's square
-        raw.transpose
-        @raw = raw
+      def initialize(raw, conversion_procs = NULL_CONVERSIONS.dup)
         @cells_class = Cells
         @cell_class = Cell
-        @conversion_procs = conversions
+
+        # Verify that it's square
+        transposed = raw.transpose
+        create_cell_matrix(raw)
+        @conversion_procs = conversion_procs
       end
 
       # Creates a copy of this table, inheriting the column mappings.
       def dup
-        self.class.new(@raw.dup, @conversion_procs.dup)
+        self.class.new(raw.dup, @conversion_procs.dup)
       end
 
       # Returns a new, transposed table. Example:
@@ -42,7 +45,7 @@ module Cucumber
       # | 4 | 2 |
       #
       def transpose
-        self.class.new(@raw.transpose, @conversion_procs.dup)
+        self.class.new(raw.transpose, @conversion_procs.dup)
       end
 
       # Converts this table into an Array of Hash where the keys of each
@@ -78,8 +81,9 @@ module Cucumber
       # The table must be exactly two columns wide 
       #
       def rows_hash
+        return @rows_hash if @rows_hash
         verify_table_width(2)
-        @rows_hash = self.transpose.hashes[0]
+        @rows_hash = self.transpose.hashes[0].freeze
       end
 
       # Gets the raw data of this table. For example, a Table built from
@@ -88,17 +92,21 @@ module Cucumber
       #   | a | b |
       #   | c | d |
       #
-      # Get converted into the following:
+      # gets converted into the following:
       #
       #   [['a', 'b], ['c', 'd']]
       #
       def raw
-        @raw
+        cell_matrix.map do |row|
+          row.map do |cell|
+            cell.value
+          end
+        end
       end
 
       # Same as #raw, but skips the first (header) row
       def rows
-        @raw[1..-1]
+        raw[1..-1]
       end
 
       def each_cells_row(&proc)
@@ -117,7 +125,7 @@ module Cucumber
         [:table, *cells_rows.map{|row| row.to_sexp}]
       end
 
-      # Returns a new Table where the headers are redefined. This makes it
+      # Redefines the table headers. This makes it
       # possible to use prettier header names in the features. Example:
       #
       #   | Phone Number | Address |
@@ -130,6 +138,18 @@ module Cucumber
       #   hashes = mapped_table.hashes
       #   # => [{:phone => '123456', :address => 'xyz'}, {:phone => '345678', :address => 'abc'}]
       #
+      def map_headers!(mappings)
+        header_cells = cell_matrix[0]
+        mappings.each_pair do |pre, post|
+          header_cell = header_cells.detect{|cell| cell.value == pre}
+          header_cell.value = post
+          if @conversion_procs.has_key?(pre)
+            @conversion_procs[post] = @conversion_procs.delete(pre)
+          end
+        end
+      end
+
+      # Returns a new Table where the headers are redefined. See #map_headers!
       def map_headers(mappings)
         table = self.dup
         table.map_headers!(mappings)
@@ -153,11 +173,110 @@ module Cucumber
         @conversion_procs[column_name] = conversion_proc
       end
 
+      # Compares +other_table+ to self. If +other_table+ contains columns
+      # and/or rows that are not in self, new columns/rows are added at the
+      # relevant positions, marking the cells in those rows/columns as
+      # <tt>surplus</tt>. Likewise, if +other_table+ lacks columns and/or 
+      # rows that are present in self, these are marked as <tt>missing</tt>.
+      #
+      # <tt>surplus</tt> and <tt>missing</tt> cells are recognised by formatters
+      # and displayed so that it's easy to read the differences.
+      #
+      # Cells that are different, but <em>look</em> identical (for example the
+      # boolean true and the string "true") are converted to their Object#inspect
+      # representation and preceded with (i) - to make it easier to identify
+      # where the difference actually is.
+      #
+      # Since all tables that are passed to StepDefinitions always have String
+      # objects in their cells, you may want to use #map_column! before calling
+      # #diff!
+      #
+      # An exception is raised if there are missing rows or columns, or
+      # surplus rows. An error is <em>not</em> raised for surplus columns.
+      # Whether to raise or not raise can be changed by setting values in
+      # +options+ to true or false:
+      #
+      #   * <tt>missing_row</tt>: Raise on missing rows (defaults to true)
+      #   * <tt>surplus_row</tt>: Raise on surplus rows (defaults to true)
+      #   * <tt>missing_col</tt>: Raise on missing columns (defaults to true)
+      #   * <tt>surplus_col</tt>: Raise on surplus columns (defaults to false)
+      #
+      # The +other_table+ argument can be another Table, an Array of Array or
+      # an Array of Hash (similar to the structure returned by #hashes).
+      #
+      # Calling this method is particularly useful in <tt>Then</tt> steps that take
+      # a Table argument, if you want to compare that table to some actual values. 
+      #
+      def diff!(other_table, options={})
+        options = {:missing_row => true, :surplus_row => true, :missing_col => true, :surplus_col => false}.merge(options)
+
+        other_table = ensure_table(other_table)
+        ensure_green!
+
+        original_width = cell_matrix[0].length
+        other_table_cell_matrix = pad!(other_table.cell_matrix)
+        padded_width = cell_matrix[0].length
+
+        missing_col = cell_matrix[0].detect{|cell| cell.status == :undefined}
+        surplus_col = padded_width > original_width
+
+        require_diff_lcs
+        cell_matrix.extend(Diff::LCS)
+        convert_columns!
+        changes = cell_matrix.diff(other_table_cell_matrix).flatten
+
+        inserted = 0
+        missing  = 0
+
+        row_indices = Array.new(other_table_cell_matrix.length) {|n| n}
+
+        last_change = nil
+        missing_row_pos = nil
+        insert_row_pos  = nil
+        
+        changes.each do |change|
+          if(change.action == '-')
+            missing_row_pos = change.position + inserted
+            cell_matrix[missing_row_pos].each{|cell| cell.status = :undefined}
+            row_indices.insert(missing_row_pos, nil)
+            missing += 1
+          else # '+'
+            insert_row_pos = change.position + missing
+            inserted_row = change.element
+            inserted_row.each{|cell| cell.status = :comment}
+            cell_matrix.insert(insert_row_pos, inserted_row)
+            row_indices[insert_row_pos] = nil
+            inspect_rows(cell_matrix[missing_row_pos], inserted_row) if last_change && last_change.action == '-'
+            inserted += 1
+          end
+          last_change = change
+        end
+
+        other_table_cell_matrix.each_with_index do |other_row, i|
+          row_index = row_indices.index(i)
+          row = cell_matrix[row_index] if row_index
+          if row
+            (original_width..padded_width).each do |col_index|
+              surplus_cell = other_row[col_index]
+              row[col_index].value = surplus_cell.value if row[col_index]
+            end
+          end
+        end
+        
+        clear_cache!
+        should_raise = 
+          missing_row_pos && options[:missing_row] ||
+          insert_row_pos  && options[:surplus_row] ||
+          missing_col     && options[:missing_col] ||
+          surplus_col     && options[:surplus_col]
+        raise 'Tables were not identical' if should_raise
+      end
+
       def to_hash(cells) #:nodoc:
         hash = Hash.new do |hash, key|
           hash[key.to_s] if key.is_a?(Symbol)
         end
-        @raw[0].each_with_index do |column_name, column_index|
+        raw[0].each_with_index do |column_name, column_index|
           value = @conversion_procs[column_name].call(cells.value(column_index))
           hash[column_name] = value
         end
@@ -169,11 +288,11 @@ module Cucumber
       end
 
       def verify_column(column_name)
-        raise %{The column named "#{column_name}" does not exist} unless @raw[0].include?(column_name)
+        raise %{The column named "#{column_name}" does not exist} unless raw[0].include?(column_name)
       end
       
       def verify_table_width(width)
-        raise %{The table must have exactly #{width} columns} unless @raw[0].size == width
+        raise %{The table must have exactly #{width} columns} unless raw[0].size == width
       end
 
       def arguments_replaced(arguments) #:nodoc:
@@ -198,33 +317,88 @@ module Cucumber
       def cells_rows
         @rows ||= cell_matrix.map do |cell_row|
           @cells_class.new(self, cell_row)
-        end.freeze
+        end
       end
 
       def headers
-        @raw.first
+        raw.first
       end
 
       def header_cell(col)
         cells_rows[0][col]
       end
 
+      def cell_matrix
+        @cell_matrix
+      end
+
+      def col_width(col)
+        columns[col].__send__(:width)
+      end
+
+      def to_s(options = {})
+        options = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge(options)
+        io = StringIO.new
+
+        c = Term::ANSIColor.coloring?
+        Term::ANSIColor.coloring = options[:color]
+        f = Formatter::Pretty.new(nil, io, options)
+        f.instance_variable_set('@indent', options[:indent])
+        f.visit_multiline_arg(self)
+        Term::ANSIColor.coloring = c
+
+        io.rewind
+        s = "\n" + io.read + (" " * (options[:indent] - 2))
+        s
+      end
+
+      private
+
+      TO_S_PREFIXES = Hash.new('    ')
+      TO_S_PREFIXES[:comment]   = ['(+) ']
+      TO_S_PREFIXES[:undefined] = ['(-) ']
+
       protected
 
-      def map_headers!(mappings)
-        headers = @raw[0]
-        mappings.each_pair do |pre, post|
-          headers[headers.index(pre)] = post
-          if @conversion_procs.has_key?(pre)
-            @conversion_procs[post] = @conversion_procs.delete(pre)
+      def inspect_rows(missing_row, inserted_row)
+        missing_row.each_with_index do |missing_cell, col|
+          inserted_cell = inserted_row[col]
+          if(missing_cell.value != inserted_cell.value && (missing_cell.value.to_s == inserted_cell.value.to_s))
+            missing_cell.inspect!
+            inserted_cell.inspect!
           end
         end
       end
 
-      private
+      def create_cell_matrix(raw)
+        @cell_matrix = raw.map do |raw_row|
+          line = raw_row.line rescue -1
+          raw_row.map do |raw_cell|
+            new_cell(raw_cell, line)
+          end
+        end
+      end
 
-      def col_width(col)
-        columns[col].__send__(:width)
+      def convert_columns!
+        cell_matrix.transpose.each do |col|
+          conversion_proc = @conversion_procs[col[0].value]
+          col[1..-1].each do |cell|
+            cell.value = conversion_proc.call(cell.value)
+          end
+        end
+      end
+
+      def require_diff_lcs
+        begin
+          require 'diff/lcs'
+        rescue LoadError => e
+          e.message << "\n Please gem install diff-lcs\n"
+          raise e
+        end
+      end
+
+      def clear_cache!
+        @hashes = @rows_hash = @rows = @columns = nil
       end
 
       def columns
@@ -233,17 +407,73 @@ module Cucumber
         end.freeze
       end
 
-      def cell_matrix
-        row = -1
-        @cell_matrix ||= @raw.map do |raw_row|
-          line = raw_row.line rescue -1
-          row += 1
-          col = -1
-          raw_row.map do |raw_cell|
-            col += 1
-            @cell_class.new(raw_cell, self, row, col, line)
+      def new_cell(raw_cell, line)
+        @cell_class.new(raw_cell, self, line)
+      end
+
+      # Pads our own cell_matrix and returns a cell matrix of same
+      # column width that can be used for diffing
+      def pad!(other_cell_matrix)
+        clear_cache!
+        cols = cell_matrix.transpose
+        unmapped_cols = other_cell_matrix.transpose
+
+        mapped_cols = []
+
+        cols.each_with_index do |col, col_index|
+          header = col[0]
+          candidate_cols, unmapped_cols = unmapped_cols.partition do |other_col|
+            other_col[0] == header
           end
-        end.freeze
+          raise "More than one column has the header #{header}" if candidate_cols.size > 2
+
+          other_padded_col = if candidate_cols.size == 1
+            # Found a matching column
+            candidate_cols[0]
+          else
+            mark_as_missing(cols[col_index])
+            (0...other_cell_matrix.length).map do |row|
+              val = row == 0 ? header.value : nil
+              SurplusCell.new(val, self, -1)
+            end
+          end
+          mapped_cols.insert(col_index, other_padded_col)
+        end
+
+        unmapped_cols.each_with_index do |col, col_index|
+          empty_col = (0...cell_matrix.length).map do |row| 
+            SurplusCell.new(nil, self, -1)
+          end
+          cols << empty_col
+        end
+
+        @cell_matrix = cols.transpose
+        (mapped_cols + unmapped_cols).transpose
+      end
+
+      def ensure_table(table_or_array)
+        return table_or_array if Table === table_or_array
+        table_or_array = hashes_to_array(table_or_array) if Hash === table_or_array[0]
+        Table.new(table_or_array)
+      end
+
+      def hashes_to_array(hashes)
+        header = hashes[0].keys
+        [header] + hashes.map{|hash| header.map{|key| hash[key]}}
+      end
+
+      def ensure_green!
+        each_cell{|cell| cell.status = :passed}
+      end
+
+      def each_cell(&proc)
+        cell_matrix.each{|row| row.each(&proc)}
+      end
+
+      def mark_as_missing(col)
+        col.each do |cell|
+          cell.status = :undefined
+        end
       end
 
       # Represents a row of cells or columns of cells
@@ -303,30 +533,38 @@ module Cucumber
       end
 
       class Cell
-        attr_reader :value, :line
-        attr_writer :status
+        attr_reader :line, :table
+        attr_accessor :status, :value
 
-        def initialize(value, table, row, col, line)
-          @value, @table, @row, @col, @line = value, table, row, col, line
+        def initialize(value, table, line)
+          @value, @table, @line = value, table, line
         end
 
         def accept(visitor)
-          visitor.visit_table_cell_value(@value, col_width, @status)
+          visitor.visit_table_cell_value(value, status)
+        end
+
+        def inspect!
+          @value = "(i) #{value.inspect}"
         end
 
-        def header_cell
-          @table.header_cell(@col)
+        def ==(o)
+          SurplusCell === o || value == o.value
         end
 
         # For testing only
         def to_sexp #:nodoc:
           [:cell, @value]
         end
+      end
+      
+      class SurplusCell < Cell
+        def status
+          :comment
+        end
 
-        private
-
-        def col_width
-          @col_width ||= @table.__send__(:col_width, @col).freeze
+        def ==(o)
+          true
         end
       end
     end

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

@@ -102,7 +102,9 @@ module Cucumber
             "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.",
@@ -268,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.
@@ -310,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('::')

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/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/html.rb

@@ -214,7 +214,7 @@ module Cucumber
         @outline_row += 1 if @outline_row
       end
 
-      def visit_table_cell_value(value, width, status)
+      def visit_table_cell_value(value, status)
         cell_type = @outline_row == 0 ? :th : :td
         attributes = {:id => "#{@row_id}_#{@col_index}", :class => 'val'}
         attributes[:class] += " #{status}" if status