cucumber 1.3.20 → 2.0.0.beta.1

data/lib/cucumber/ast/step.rb

@@ -1,122 +0,0 @@
-require 'cucumber/core_ext/string'
-require 'cucumber/step_match'
-require 'cucumber/ast/location'
-
-module Cucumber
-  module Ast
-    class Step #:nodoc:
-      include HasLocation
-
-      attr_reader :keyword, :name, :language
-      attr_writer :step_collection, :options
-      attr_accessor :feature_element, :exception, :multiline_arg
-
-      INDENT = 2
-
-      def initialize(language, location, keyword, name, multiline_arg=nil)
-        @language, @location, @keyword, @name, @multiline_arg = language, location, keyword, name, multiline_arg
-        @language || raise("Language is required!")
-      end
-
-      attr_reader :gherkin_statement
-      def gherkin_statement(statement=nil)
-        @gherkin_statement ||= statement
-      end
-
-      def background?
-        false
-      end
-
-      def status
-        # Step always has status skipped, because Step is always in a ScenarioOutline
-        :skipped
-      end
-
-      def step_invocation
-        StepInvocation.new(self, name, @multiline_arg, [])
-      end
-
-      def step_invocation_from_cells(cells)
-        matched_cells = matched_cells(cells)
-
-        delimited_arguments = delimit_argument_names(cells.to_hash)
-        name                = replace_name_arguments(delimited_arguments)
-        multiline_arg       = @multiline_arg.nil? ? nil : @multiline_arg.arguments_replaced(delimited_arguments)
-
-        StepInvocation.new(self, name, multiline_arg, matched_cells)
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        # The only time a Step is visited is when it is in a ScenarioOutline.
-        # Otherwise it's always StepInvocation that gets visited instead.
-        visit_step_result(visitor, first_match(visitor), @multiline_arg, :skipped, nil, nil)
-      end
-
-      def visit_step_result(visitor, step_match, multiline_arg, status, exception, background)
-        visitor.visit_step_result(keyword, step_match, @multiline_arg, status, exception, source_indent, background, file_colon_line)
-      end
-
-      def first_match(visitor)
-        # feature_element is always a ScenarioOutline in this case
-        feature_element.each_example_row do |cells|
-          argument_hash       = cells.to_hash
-          delimited_arguments = delimit_argument_names(argument_hash)
-          name_to_match       = replace_name_arguments(delimited_arguments)
-          step_match          = visitor.runtime.step_match(name_to_match, name) rescue nil
-          return step_match if step_match
-        end
-        NoStepMatch.new(self, name)
-      end
-
-      def to_sexp
-        [:step, line, keyword, name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
-      end
-
-      def source_indent
-        feature_element.source_indent(text_length)
-      end
-
-      def text_length(name=name())
-        INDENT + INDENT + keyword.unpack('U*').length + name.unpack('U*').length
-      end
-
-      def backtrace_line
-        @backtrace_line ||= feature_element.backtrace_line("#{keyword}#{name}", line) unless feature_element.nil?
-      end
-
-      def dom_id
-        @dom_id ||= file_colon_line.gsub(/\//, '_').gsub(/\./, '_').gsub(/:/, '_')
-      end
-
-      private
-
-      def matched_cells(cells)
-        col_index = 0
-        cells.select do |cell|
-          header_cell = cell.table.header_cell(col_index)
-          col_index += 1
-          delimited = delimited(header_cell.value)
-          name.index(delimited) || (@multiline_arg && @multiline_arg.has_text?(delimited))
-        end
-      end
-
-      def delimit_argument_names(argument_hash)
-        argument_hash.inject({}) { |h,(name,value)| h[delimited(name)] = value; h }
-      end
-
-      def delimited(s)
-        "<#{s}>"
-      end
-
-      def replace_name_arguments(argument_hash)
-        name_with_arguments_replaced = name
-        argument_hash.each do |key, value|
-          value ||= ''
-          name_with_arguments_replaced = name_with_arguments_replaced.gsub(key, value)
-        end
-        name_with_arguments_replaced
-      end
-    end
-  end
-end

data/lib/cucumber/ast/step_collection.rb

@@ -1,92 +0,0 @@
-module Cucumber
-  module Ast
-    # Holds an Array of Step or StepDefinition
-    class StepCollection #:nodoc:
-      include Enumerable
-
-      def initialize(steps)
-        @steps = steps
-        @steps.each{|step| step.step_collection = self}
-      end
-
-      def inspect
-        @steps.map { |s| [s.class, s.object_id] }.join(', ')
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        @steps.each do |step|
-          visitor.visit_step(step)
-        end
-      end
-
-      def step_invocations(background = false)
-        StepCollection.new(@steps.map{ |step|
-          i = step.step_invocation
-          i.background = background
-          i
-        })
-      end
-
-      def skip_invoke!
-        @steps.each{|step_invocation| step_invocation.skip_invoke!}
-      end
-
-      def step_invocations_from_cells(cells)
-        @steps.map{|step| step.step_invocation_from_cells(cells)}
-      end
-
-      def +(step_invocations)
-        dup(step_invocations)
-      end
-
-      # Duplicates this instance and adds +step_invocations+ to the end
-      def dup(step_invocations = [])
-        StepCollection.new(@steps + step_invocations)
-      end
-
-      def each(&proc)
-        @steps.each(&proc)
-      end
-
-      def previous_step(step)
-        i = @steps.index(step) || -1
-        @steps[i-1]
-      end
-
-      def empty?
-        @steps.empty?
-      end
-
-      def max_line_length(feature_element)
-        lengths = (@steps + [feature_element]).map{|e| e.text_length}
-        lengths.max
-      end
-
-      def exception
-        @exception ||= ((failed = @steps.detect {|step| step.exception}) && failed.exception)
-      end
-
-      def failed?
-        status == :failed
-      end
-
-      def passed?
-        status == :passed
-      end
-
-      def status
-        @steps.each{|step_invocation| return step_invocation.status if step_invocation.status != :passed}
-        :passed
-      end
-
-      def length
-        @steps.length
-      end
-
-      def to_sexp
-        @steps.map{|step| step.to_sexp}
-      end
-    end
-  end
-end

data/lib/cucumber/ast/step_invocation.rb

@@ -1,196 +0,0 @@
-require 'cucumber/errors'
-require 'cucumber/step_match'
-require 'cucumber/ast/table'
-require 'gherkin/rubify'
-
-module Cucumber
-  module Ast
-    class StepInvocation #:nodoc:
-      include Gherkin::Rubify
-
-      attr_writer :step_collection, :background
-      attr_reader :name, :matched_cells, :status, :reported_exception
-      attr_accessor :exception
-
-      class << self
-        SEVERITY = [:passed, :undefined, :pending, :skipped, :failed]
-        def worst_status(statuses)
-          SEVERITY[statuses.map{|status| SEVERITY.index(status)}.max]
-        end
-      end
-
-      def initialize(step, name, multiline_arg, matched_cells)
-        @step, @name, @multiline_arg, @matched_cells = step, name, multiline_arg, matched_cells
-        status!(:skipped)
-        @skip_invoke = @exception = @step_match = @different_table = @reported_exception = @background = nil
-      end
-
-      def background?
-        @background
-      end
-
-      def skip_invoke!
-        @skip_invoke = true
-      end
-
-      def accept(visitor)
-        return if Cucumber.wants_to_quit
-        invoke(visitor.runtime, visitor.configuration)
-        visit_step_result(visitor)
-      end
-
-      def visit_step_result(visitor)
-        visitor.visit_step_result(
-          keyword,
-          @step_match,
-          (@different_table || @multiline_arg),
-          @status,
-          @reported_exception,
-          source_indent,
-          @background,
-          file_colon_line
-        )
-      end
-
-      def invoke(runtime, configuration)
-        find_step_match!(runtime, configuration)
-        unless @skip_invoke || configuration.dry_run? || @exception || @step_collection.exception
-          @skip_invoke = true
-          begin
-            @step_match.invoke(@multiline_arg)
-            runtime.after_step
-            status!(:passed)
-          rescue Pending => e
-            failed(configuration, e, false)
-            status!(:pending)
-          rescue Undefined => e
-            failed(configuration, e, false)
-            status!(:undefined)
-          rescue Cucumber::Ast::Table::Different => e
-            @different_table = e.table
-            failed(configuration, e, false)
-            status!(:failed)
-          rescue Exception => e
-            failed(configuration, e, false)
-            status!(:failed)
-          end
-        end
-      end
-
-      def find_step_match!(runtime, configuration)
-        return if @step_match
-        begin
-          @step_match = runtime.step_match(@name)
-        rescue Undefined => e
-          failed(configuration, e, true)
-          status!(:undefined)
-          @step_match = NoStepMatch.new(@step, @name)
-        rescue Ambiguous => e
-          failed(configuration, e, false)
-          status!(:failed)
-          @step_match = NoStepMatch.new(@step, @name)
-        end
-        runtime.step_visited(self)
-      end
-
-      def failed(configuration, e, clear_backtrace)
-        e.set_backtrace([]) if e.backtrace.nil? || clear_backtrace
-        e.backtrace << @step.backtrace_line unless @step.backtrace_line.nil?
-        e = filter_backtrace(e)
-        @exception = e
-        if(configuration.strict? || !(Undefined === e) || e.nested?)
-          @reported_exception = e
-        else
-          @reported_exception = nil
-        end
-      end
-
-      # This constant is appended to by Cuke4Duke. Do not change its name
-      BACKTRACE_FILTER_PATTERNS = [/vendor\/rails|lib\/cucumber|bin\/cucumber:|lib\/rspec|gems\/|minitest|test\/unit|lib\/ruby/]
-      if(Cucumber::JRUBY)
-        BACKTRACE_FILTER_PATTERNS << /org\/jruby/
-      end
-      PWD_PATTERN = /#{Regexp.escape(Dir.pwd)}\//m
-
-      # This is to work around double ":in " segments in JRuby backtraces. JRuby bug?
-      def filter_backtrace(e)
-        return e if Cucumber.use_full_backtrace
-        e.backtrace.each{|line| line.gsub!(PWD_PATTERN, "./")}
-
-        filtered = (e.backtrace || []).reject do |line|
-          BACKTRACE_FILTER_PATTERNS.detect { |p| line =~ p }
-        end
-
-        if ENV['CUCUMBER_TRUNCATE_OUTPUT']
-          # Strip off file locations
-          filtered = filtered.map do |line|
-            line =~ /(.*):in `/ ? $1 : line
-          end
-        end
-
-        e.set_backtrace(filtered)
-        e
-      end
-
-      def status!(status)
-        @status = status
-        @matched_cells.each do |cell|
-          cell.status = status
-        end
-      end
-
-      def previous
-        @step_collection.previous_step(self)
-      end
-
-      def actual_keyword
-        repeat_keywords = rubify([language.keywords('but'), language.keywords('and')]).flatten.uniq.reject{|kw| kw == '* '}
-        if repeat_keywords.index(@step.keyword) && previous
-          previous.actual_keyword
-        else
-          keyword == '* ' ? language.code_keywords.first : keyword
-        end
-      end
-
-      def source_indent
-        @step.feature_element.source_indent(text_length)
-      end
-
-      def text_length
-        @step.text_length(@name)
-      end
-
-      def keyword
-        @step.keyword
-      end
-
-      def multiline_arg
-        @step.multiline_arg
-      end
-
-      def file_colon_line
-        @step.file_colon_line
-      end
-
-      def dom_id
-        @step.dom_id
-      end
-
-      def backtrace_line
-        @step.backtrace_line
-      end
-
-      def language
-        @step.language || raise("Language is required on #{@step}")
-      end
-
-      def gherkin_statement
-        @step.gherkin_statement
-      end
-
-      def to_sexp
-        [:step_invocation, @step.line, @step.keyword, @name, (@multiline_arg.nil? ? nil : @multiline_arg.to_sexp)].compact
-      end
-    end
-  end
-end

data/lib/cucumber/ast/table.rb

@@ -1,738 +0,0 @@
-require 'gherkin/rubify'
-require 'gherkin/lexer/i18n_lexer'
-require 'gherkin/formatter/escaping'
-
-module Cucumber
-  module Ast
-    # Step Definitions that match a plain text Step with a multiline argument table
-    # will receive it as an instance of Table. A Table object holds the data of a
-    # table parsed from a feature file and lets you access and manipulate the data
-    # in different ways.
-    #
-    # For example:
-    #
-    #   Given I have:
-    #     | a | b |
-    #     | c | d |
-    #
-    # And a matching StepDefinition:
-    #
-    #   Given /I have:/ do |table|
-    #     data = table.raw
-    #   end
-    #
-    # This will store <tt>[['a', 'b'], ['c', 'd']]</tt> in the <tt>data</tt> variable.
-    #
-    class Table
-      class Different < StandardError
-        attr_reader :table
-
-        def initialize(table)
-          super('Tables were not identical')
-          @table = table
-        end
-      end
-
-      class Builder
-        attr_reader :rows
-
-        def initialize
-          @rows = []
-        end
-
-        def row(row, line_number)
-          @rows << row
-        end
-
-        def eof
-        end
-      end
-
-      include Enumerable
-      include Gherkin::Rubify
-
-      NULL_CONVERSIONS = Hash.new({ :strict => false, :proc => lambda{ |cell_value| cell_value } }).freeze
-
-      attr_accessor :file
-
-      def self.default_arg_name #:nodoc:
-        "table"
-      end
-
-      def self.parse(text, uri, offset)
-        builder = Builder.new
-        lexer = Gherkin::Lexer::I18nLexer.new(builder)
-        lexer.scan(text)
-        new(builder.rows)
-      end
-
-      # Creates a new instance. +raw+ should be an Array of Array of String
-      # or an Array of Hash (similar to what #hashes returns).
-      # You don't typically create your own Table objects - Cucumber will do
-      # it internally and pass them to your Step Definitions.
-      #
-      def initialize(raw, conversion_procs = NULL_CONVERSIONS.dup, header_mappings = {}, header_conversion_proc = nil)
-        @cells_class = Cells
-        @cell_class = Cell
-        raw = ensure_array_of_array(rubify(raw))
-        # Verify that it's square
-        raw.transpose
-        create_cell_matrix(raw)
-        @conversion_procs = conversion_procs
-        @header_mappings = header_mappings
-        @header_conversion_proc = header_conversion_proc
-      end
-
-      def to_step_definition_arg
-        dup
-      end
-
-      # Creates a copy of this table, inheriting any column and header mappings
-      # registered with #map_column! and #map_headers!.
-      #
-      def dup
-        self.class.new(raw.dup, @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
-      end
-
-      # Returns a new, transposed table. Example:
-      #
-      #   | a | 7 | 4 |
-      #   | b | 9 | 2 |
-      #
-      # Gets converted into the following:
-      #
-      #   | a | b |
-      #   | 7 | 9 |
-      #   | 4 | 2 |
-      #
-      def transpose
-        self.class.new(raw.transpose, @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc)
-      end
-
-      # Converts this table into an Array of Hash where the keys of each
-      # Hash are the headers in the table. For example, a Table built from
-      # the following plain text:
-      #
-      #   | a | b | sum |
-      #   | 2 | 3 | 5   |
-      #   | 7 | 9 | 16  |
-      #
-      # Gets converted into the following:
-      #
-      #   [{'a' => '2', 'b' => '3', 'sum' => '5'}, {'a' => '7', 'b' => '9', 'sum' => '16'}]
-      #
-      # Use #map_column! to specify how values in a column are converted.
-      #
-      def hashes
-        @hashes ||= build_hashes
-      end
-
-      # Converts this table into a Hash where the first column is
-      # used as keys and the second column is used as values
-      #
-      #   | a | 2 |
-      #   | b | 3 |
-      #
-      # Gets converted into the following:
-      #
-      #   {'a' => '2', 'b' => '3'}
-      #
-      # 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]
-      end
-
-      # Gets the raw data of this table. For example, a Table built from
-      # the following plain text:
-      #
-      #   | a | b |
-      #   | c | d |
-      #
-      # gets converted into the following:
-      #
-      #   [['a', 'b'], ['c', 'd']]
-      #
-      def raw
-        cell_matrix.map do |row|
-          row.map do |cell|
-            cell.value
-          end
-        end
-      end
-
-      def column_names #:nodoc:
-        @col_names ||= cell_matrix[0].map { |cell| cell.value }
-      end
-
-      def rows
-        hashes.map do |hash|
-          hash.values_at *headers
-        end
-      end
-
-      def each_cells_row(&proc) #:nodoc:
-        cells_rows.each(&proc)
-      end
-
-      def accept(visitor) #:nodoc:
-        return if Cucumber.wants_to_quit
-        cells_rows.each do |row|
-          visitor.visit_table_row(row)
-        end
-        nil
-      end
-
-      # Matches +pattern+ against the header row of the table.
-      # This is used especially for argument transforms.
-      #
-      # Example:
-      #  | column_1_name | column_2_name |
-      #  | x             | y             |
-      #
-      #  table.match(/table:column_1_name,column_2_name/) #=> non-nil
-      #
-      # Note: must use 'table:' prefix on match
-      def match(pattern)
-        header_to_match = "table:#{headers.join(',')}"
-        pattern.match(header_to_match)
-      end
-
-      # For testing only
-      def to_sexp #:nodoc:
-        [:table, *cells_rows.map{|row| row.to_sexp}]
-      end
-
-      # Redefines the table headers. This makes it possible to use
-      # prettier and more flexible header names in the features.  The
-      # keys of +mappings+ are Strings or regular expressions
-      # (anything that responds to #=== will work) that may match
-      # column headings in the table.  The values of +mappings+ are
-      # desired names for the columns.
-      #
-      # Example:
-      #
-      #   | Phone Number | Address |
-      #   | 123456       | xyz     |
-      #   | 345678       | abc     |
-      #
-      # A StepDefinition receiving this table can then map the columns
-      # with both Regexp and String:
-      #
-      #   table.map_headers!(/phone( number)?/i => :phone, 'Address' => :address)
-      #   table.hashes
-      #   # => [{:phone => '123456', :address => 'xyz'}, {:phone => '345678', :address => 'abc'}]
-      #
-      # You may also pass in a block if you wish to convert all of the headers:
-      #
-      #   table.map_headers! { |header| header.downcase }
-      #   table.hashes.keys
-      #   # => ['phone number', 'address']
-      #
-      # When a block is passed in along with a hash then the mappings in the hash take precendence:
-      #
-      #   table.map_headers!('Address' => 'ADDRESS') { |header| header.downcase }
-      #   table.hashes.keys
-      #   # => ['phone number', 'ADDRESS']
-      #
-      def map_headers!(mappings={}, &block)
-        # TODO: Remove this method for 2.0
-        clear_cache!
-        @header_mappings = mappings
-        @header_conversion_proc = block
-      end
-
-      # Returns a new Table where the headers are redefined. See #map_headers!
-      def map_headers(mappings={}, &block)
-        self.class.new raw.dup, @conversion_procs.dup, mappings, block
-      end
-
-      # Change how #hashes converts column values. The +column_name+ argument identifies the column
-      # and +conversion_proc+ performs the conversion for each cell in that column. If +strict+ is
-      # true, an error will be raised if the column named +column_name+ is not found. If +strict+
-      # is false, no error will be raised. Example:
-      #
-      #   Given /^an expense report for (.*) with the following posts:$/ do |table|
-      #     posts_table.map_column!('amount') { |a| a.to_i }
-      #     posts_table.hashes.each do |post|
-      #       # post['amount'] is a Fixnum, rather than a String
-      #     end
-      #   end
-      #
-      def map_column!(column_name, strict=true, &conversion_proc)
-        # TODO: Remove this method for 2.0
-        @conversion_procs[column_name.to_s] = { :strict => strict, :proc => conversion_proc }
-        self
-      end
-
-      # Returns a new Table with an additional column mapping. See #map_column!
-      def map_column(column_name, strict=true, &conversion_proc)
-        conversion_procs = @conversion_procs.dup
-        conversion_procs[column_name.to_s] = { :strict => strict, :proc => conversion_proc }
-        self.class.new(raw.dup, conversion_procs, @header_mappings.dup, @header_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!. You can use #map_column! on either of the tables.
-      #
-      # A Different error is raised if there are missing rows or columns, or
-      # surplus rows. An error is <em>not</em> raised for surplus columns. An
-      # error is <em>not</em> raised for misplaced (out of sequence) 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)
-      # * <tt>misplaced_col</tt> : Raise on misplaced 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,
-          :misplaced_col => false
-        }.merge(options)
-
-        other_table = ensure_table(other_table)
-        other_table.convert_headers!
-        other_table.convert_columns!
-        ensure_green!
-
-        convert_headers!
-        convert_columns!
-
-        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
-        misplaced_col = cell_matrix[0] != other_table.cell_matrix[0]
-
-        require_diff_lcs
-        cell_matrix.extend(Diff::LCS)
-        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] ||
-          misplaced_col   && options[:misplaced_col]
-        raise Different.new(self) 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
-        column_names.each_with_index do |column_name, column_index|
-          hash[column_name] = cells.value(column_index)
-        end
-        hash
-      end
-
-      def index(cells) #:nodoc:
-        cells_rows.index(cells)
-      end
-
-      def verify_column(column_name) #:nodoc:
-        raise %{The column named "#{column_name}" does not exist} unless raw[0].include?(column_name)
-      end
-
-      def verify_table_width(width) #:nodoc:
-        raise %{The table must have exactly #{width} columns} unless raw[0].size == width
-      end
-
-      def arguments_replaced(arguments) #:nodoc:
-        raw_with_replaced_args = raw.map do |row|
-          row.map do |cell|
-            cell_with_replaced_args = cell
-            arguments.each do |name, value|
-              if cell_with_replaced_args && cell_with_replaced_args.include?(name)
-                cell_with_replaced_args = value ? cell_with_replaced_args.gsub(name, value) : nil
-              end
-            end
-            cell_with_replaced_args
-          end
-        end
-        Table.new(raw_with_replaced_args)
-      end
-
-      def has_text?(text) #:nodoc:
-        raw.flatten.compact.detect{|cell_value| cell_value.index(text)}
-      end
-
-      def cells_rows #:nodoc:
-        @rows ||= cell_matrix.map do |cell_row|
-          @cells_class.new(self, cell_row)
-        end
-      end
-
-      def headers #:nodoc:
-        raw.first
-      end
-
-      def header_cell(col) #:nodoc:
-        cells_rows[0][col]
-      end
-
-      def cell_matrix #:nodoc:
-        @cell_matrix
-      end
-
-      def col_width(col) #:nodoc:
-        columns[col].__send__(:width)
-      end
-
-      def to_s(options = {}) #:nodoc:
-        require 'cucumber/formatter/pretty'
-        options = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge(options)
-        io = StringIO.new
-
-        c = Cucumber::Term::ANSIColor.coloring?
-        Cucumber::Term::ANSIColor.coloring = options[:color]
-        formatter = Formatter::Pretty.new(nil, io, options)
-        formatter.instance_variable_set('@indent', options[:indent])
-        TreeWalker.new(nil, [formatter]).visit_multiline_arg(self)
-
-        Cucumber::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 build_hashes
-        convert_headers!
-        convert_columns!
-        cells_rows[1..-1].map do |row|
-          row.to_hash
-        end
-      end
-
-      def inspect_rows(missing_row, inserted_row) #:nodoc:
-        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
-
-      def create_cell_matrix(raw) #:nodoc:
-        @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 convert_columns! #:nodoc:
-        @conversion_procs.each do |column_name, conversion_proc|
-          verify_column(column_name) if conversion_proc[:strict]
-        end
-
-        cell_matrix.transpose.each do |col|
-          column_name = col[0].value
-          conversion_proc = @conversion_procs[column_name][:proc]
-          col[1..-1].each do |cell|
-            cell.value = conversion_proc.call(cell.value)
-          end
-        end
-      end
-
-      def convert_headers! #:nodoc:
-        header_cells = cell_matrix[0]
-
-        if @header_conversion_proc
-          header_values = header_cells.map { |cell| cell.value } - @header_mappings.keys
-          @header_mappings = @header_mappings.merge(Hash[*header_values.zip(header_values.map(&@header_conversion_proc)).flatten])
-        end
-
-        @header_mappings.each_pair do |pre, post|
-          mapped_cells = header_cells.select { |cell| pre === cell.value }
-          raise "No headers matched #{pre.inspect}" if mapped_cells.empty?
-          raise "#{mapped_cells.length} headers matched #{pre.inspect}: #{mapped_cells.map { |c| c.value }.inspect}" if mapped_cells.length > 1
-          mapped_cells[0].value = post
-          if @conversion_procs.has_key?(pre)
-            @conversion_procs[post] = @conversion_procs.delete(pre)
-          end
-        end
-      end
-
-      def require_diff_lcs #:nodoc:
-        begin
-          require 'diff/lcs'
-        rescue LoadError => e
-          e.message << "\n Please gem install diff-lcs\n"
-          raise e
-        end
-      end
-
-      def clear_cache! #:nodoc:
-        @hashes = @rows_hash = @col_names = @rows = @columns = nil
-      end
-
-      def columns #:nodoc:
-        @columns ||= cell_matrix.transpose.map do |cell_row|
-          @cells_class.new(self, cell_row)
-        end
-      end
-
-      def new_cell(raw_cell, line) #:nodoc:
-        @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) #:nodoc:
-        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
-          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) #:nodoc:
-        return table_or_array if Table === table_or_array
-        Table.new(table_or_array)
-      end
-
-      def ensure_array_of_array(array)
-        Hash === array[0] ? hashes_to_array(array) : array
-      end
-
-      def hashes_to_array(hashes) #:nodoc:
-        header = hashes[0].keys.sort
-        [header] + hashes.map{|hash| header.map{|key| hash[key]}}
-      end
-
-      def ensure_green! #:nodoc:
-        each_cell{|cell| cell.status = :passed}
-      end
-
-      def each_cell(&proc) #:nodoc:
-        cell_matrix.each{|row| row.each(&proc)}
-      end
-
-      def mark_as_missing(col) #:nodoc:
-        col.each do |cell|
-          cell.status = :undefined
-        end
-      end
-
-      # Represents a row of cells or columns of cells
-      class Cells #:nodoc:
-        include Enumerable
-        include Gherkin::Formatter::Escaping
-
-        attr_reader :exception
-
-        def initialize(table, cells)
-          @table, @cells = table, cells
-        end
-
-        def accept(visitor)
-          return if Cucumber.wants_to_quit
-          each do |cell|
-            visitor.visit_table_cell(cell)
-          end
-          nil
-        end
-
-        # For testing only
-        def to_sexp #:nodoc:
-          [:row, line, *@cells.map{|cell| cell.to_sexp}]
-        end
-
-        def to_hash #:nodoc:
-          @to_hash ||= @table.to_hash(self)
-        end
-
-        def value(n) #:nodoc:
-          self[n].value
-        end
-
-        def [](n)
-          @cells[n]
-        end
-
-        def line
-          @cells[0].line
-        end
-
-        def dom_id
-          "row_#{line}"
-        end
-
-        private
-
-        def index
-          @table.index(self)
-        end
-
-        def width
-          map{|cell| cell.value ? escape_cell(cell.value.to_s).unpack('U*').length : 0}.max
-        end
-
-        def each(&proc)
-          @cells.each(&proc)
-        end
-      end
-
-      class Cell #:nodoc:
-        attr_reader :line, :table
-        attr_accessor :status, :value
-
-        def initialize(value, table, line)
-          @value, @table, @line = value, table, line
-        end
-
-        def accept(visitor)
-          return if Cucumber.wants_to_quit
-          visitor.visit_table_cell_value(value, status)
-        end
-
-        def inspect!
-          @value = "(i) #{value.inspect}"
-        end
-
-        def ==(o)
-          SurplusCell === o || value == o.value
-        end
-
-        def eql?(o)
-          self == o
-        end
-
-        def hash
-          0
-        end
-
-        # For testing only
-        def to_sexp #:nodoc:
-          [:cell, @value]
-        end
-      end
-
-      class SurplusCell < Cell #:nodoc:
-        def status
-          :comment
-        end
-
-        def ==(o)
-          true
-        end
-
-        def hash
-          0
-        end
-      end
-    end
-  end
-end