Class: Lucid::AST::Table
- Includes:
- Enumerable, Gherkin::Rubify
- Defined in:
- lib/lucid/ast/table.rb
Overview
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 [['a', 'b'], ['c', 'd']]
in the data
variable.
Direct Known Subclasses
Defined Under Namespace
Classes: Builder, Cell, Cells, Different, SurplusCell
Constant Summary collapse
- NULL_CONVERSIONS =
Hash.new({ :strict => false, :proc => lambda{ |cell_value| cell_value } }).freeze
Instance Attribute Summary collapse
-
#file ⇒ Object
Returns the value of attribute file.
Class Method Summary collapse
Instance Method Summary collapse
-
#accept(visitor) ⇒ Object
:nodoc:.
-
#arguments_replaced(arguments) ⇒ Object
:nodoc:.
-
#cell_matrix ⇒ Object
:nodoc:.
-
#cells_rows ⇒ Object
:nodoc:.
-
#col_width(col) ⇒ Object
:nodoc:.
-
#column_names ⇒ Object
:nodoc:.
-
#diff!(other_table, options = {}) ⇒ Object
Compares
other_table
to self. -
#dup ⇒ Object
Creates a copy of this table, inheriting any column and header mappings registered with #map_column! and #map_headers!.
-
#each_cells_row(&proc) ⇒ Object
:nodoc:.
-
#has_text?(text) ⇒ Boolean
:nodoc:.
-
#hashes ⇒ Object
Converts this table into an Array of Hash where the keys of each Hash are the headers in the table.
-
#header_cell(col) ⇒ Object
:nodoc:.
-
#headers ⇒ Object
:nodoc:.
-
#index(cells) ⇒ Object
:nodoc:.
-
#initialize(raw, conversion_procs = NULL_CONVERSIONS.dup, header_mappings = {}, header_conversion_proc = nil) ⇒ Table
constructor
Creates a new instance.
-
#map_column!(column_name, strict = true, &conversion_proc) ⇒ Object
Change how #hashes converts column values.
-
#map_headers(mappings = {}, &block) ⇒ Object
Returns a new Table where the headers are redefined.
-
#map_headers!(mappings = {}, &block) ⇒ Object
Redefines the table headers.
-
#match(pattern) ⇒ Object
Matches
pattern
against the header row of the table. -
#raw ⇒ Object
Gets the raw data of this table.
- #rows ⇒ Object
-
#rows_hash ⇒ Object
Converts this table into a Hash where the first column is used as keys and the second column is used as values.
-
#to_hash(cells) ⇒ Object
:nodoc:.
-
#to_s(options = {}) ⇒ Object
:nodoc:.
-
#to_sexp ⇒ Object
For testing only.
- #to_step_definition_arg ⇒ Object
-
#transpose ⇒ Object
Returns a new, transposed table.
-
#verify_column(column_name) ⇒ Object
:nodoc:.
-
#verify_table_width(width) ⇒ Object
:nodoc:.
Constructor Details
#initialize(raw, conversion_procs = NULL_CONVERSIONS.dup, header_mappings = {}, header_conversion_proc = nil) ⇒ Table
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 - Lucid will do it internally and pass them to your test definitions.
74 75 76 77 78 79 80 81 82 83 84 |
# File 'lib/lucid/ast/table.rb', line 74 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 |
Instance Attribute Details
#file ⇒ Object
Returns the value of attribute file.
56 57 58 |
# File 'lib/lucid/ast/table.rb', line 56 def file @file end |
Class Method Details
.default_arg_name ⇒ Object
:nodoc:
58 59 60 |
# File 'lib/lucid/ast/table.rb', line 58 def self.default_arg_name #:nodoc: "table" end |
Instance Method Details
#accept(visitor) ⇒ Object
:nodoc:
179 180 181 182 183 184 |
# File 'lib/lucid/ast/table.rb', line 179 def accept(visitor) #:nodoc: cells_rows.each do |row| row.accept(visitor) end nil end |
#arguments_replaced(arguments) ⇒ Object
:nodoc:
404 405 406 407 408 409 410 411 412 413 414 415 416 417 |
# File 'lib/lucid/ast/table.rb', line 404 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 |
#cell_matrix ⇒ Object
:nodoc:
437 438 439 |
# File 'lib/lucid/ast/table.rb', line 437 def cell_matrix #:nodoc: @cell_matrix end |
#cells_rows ⇒ Object
:nodoc:
423 424 425 426 427 |
# File 'lib/lucid/ast/table.rb', line 423 def cells_rows #:nodoc: @rows ||= cell_matrix.map do |cell_row| @cells_class.new(self, cell_row) end end |
#col_width(col) ⇒ Object
:nodoc:
441 442 443 |
# File 'lib/lucid/ast/table.rb', line 441 def col_width(col) #:nodoc: columns[col].__send__(:width) end |
#column_names ⇒ Object
:nodoc:
165 166 167 |
# File 'lib/lucid/ast/table.rb', line 165 def column_names #:nodoc: @col_names ||= cell_matrix[0].map { |cell| cell.value } end |
#diff!(other_table, options = {}) ⇒ Object
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 surplus
. Likewise, if other_table
lacks columns and/or rows that are present in self, these are marked as missing
.
surplus
and missing
cells are recognised by formatters and displayed so that it’s easy to read the differences.
Cells that are different, but look 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 not raised for surplus columns. An error is not 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:
-
missing_row
: Raise on missing rows (defaults to true) -
surplus_row
: Raise on surplus rows (defaults to true) -
missing_col
: Raise on missing columns (defaults to true) -
surplus_col
: Raise on surplus columns (defaults to false) -
misplaced_col
: 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 Then
steps that take a Table argument, if you want to compare that table to some actual values.
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 |
# File 'lib/lucid/ast/table.rb', line 305 def diff!(other_table, ={}) = { :missing_row => true, :surplus_row => true, :missing_col => true, :surplus_col => false, :misplaced_col => false }.merge() 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 && [:missing_row] || insert_row_pos && [:surplus_row] || missing_col && [:missing_col] || surplus_col && [:surplus_col] || misplaced_col && [:misplaced_col] raise Different.new(self) if should_raise end |
#dup ⇒ Object
Creates a copy of this table, inheriting any column and header mappings registered with #map_column! and #map_headers!.
92 93 94 |
# File 'lib/lucid/ast/table.rb', line 92 def dup self.class.new(raw.dup, @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc) end |
#each_cells_row(&proc) ⇒ Object
:nodoc:
175 176 177 |
# File 'lib/lucid/ast/table.rb', line 175 def each_cells_row(&proc) #:nodoc: cells_rows.each(&proc) end |
#has_text?(text) ⇒ Boolean
:nodoc:
419 420 421 |
# File 'lib/lucid/ast/table.rb', line 419 def has_text?(text) #:nodoc: raw.flatten.compact.detect{|cell_value| cell_value.index(text)} end |
#hashes ⇒ Object
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.
125 126 127 |
# File 'lib/lucid/ast/table.rb', line 125 def hashes @hashes ||= build_hashes end |
#header_cell(col) ⇒ Object
:nodoc:
433 434 435 |
# File 'lib/lucid/ast/table.rb', line 433 def header_cell(col) #:nodoc: cells_rows[0][col] end |
#headers ⇒ Object
:nodoc:
429 430 431 |
# File 'lib/lucid/ast/table.rb', line 429 def headers #:nodoc: raw.first end |
#index(cells) ⇒ Object
:nodoc:
392 393 394 |
# File 'lib/lucid/ast/table.rb', line 392 def index(cells) #:nodoc: cells_rows.index(cells) end |
#map_column!(column_name, strict = true, &conversion_proc) ⇒ Object
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
264 265 266 267 |
# File 'lib/lucid/ast/table.rb', line 264 def map_column!(column_name, strict=true, &conversion_proc) @conversion_procs[column_name.to_s] = { :strict => strict, :proc => conversion_proc } self end |
#map_headers(mappings = {}, &block) ⇒ Object
Returns a new Table where the headers are redefined. See #map_headers!
245 246 247 248 249 250 |
# File 'lib/lucid/ast/table.rb', line 245 def map_headers(mappings={}, &block) #table = self.dup #table.map_headers!(mappings) #table self.class.new raw.dump, @conversion_procs.dup, mappings, block end |
#map_headers!(mappings = {}, &block) ⇒ Object
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']
238 239 240 241 242 |
# File 'lib/lucid/ast/table.rb', line 238 def map_headers!(mappings={}, &block) clear_cache! @header_mappings = mappings @header_conversion_proc = block end |
#match(pattern) ⇒ Object
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
196 197 198 199 |
# File 'lib/lucid/ast/table.rb', line 196 def match(pattern) header_to_match = "table:#{headers.join(',')}" pattern.match(header_to_match) end |
#raw ⇒ Object
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']]
157 158 159 160 161 162 163 |
# File 'lib/lucid/ast/table.rb', line 157 def raw cell_matrix.map do |row| row.map do |cell| cell.value end end end |
#rows ⇒ Object
169 170 171 172 173 |
# File 'lib/lucid/ast/table.rb', line 169 def rows hashes.map do |hash| hash.values_at *headers end end |
#rows_hash ⇒ Object
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
141 142 143 144 145 |
# File 'lib/lucid/ast/table.rb', line 141 def rows_hash return @rows_hash if @rows_hash verify_table_width(2) @rows_hash = self.transpose.hashes[0] end |
#to_hash(cells) ⇒ Object
:nodoc:
382 383 384 385 386 387 388 389 390 |
# File 'lib/lucid/ast/table.rb', line 382 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 |
#to_s(options = {}) ⇒ Object
:nodoc:
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 |
# File 'lib/lucid/ast/table.rb', line 445 def to_s( = {}) #:nodoc: require 'lucid/formatter/standard' = {:color => true, :indent => 2, :prefixes => TO_S_PREFIXES}.merge() io = StringIO.new c = Lucid::Term::ANSIColor.coloring? Lucid::Term::ANSIColor.coloring = [:color] formatter = Formatter::Standard.new(nil, io, ) formatter.instance_variable_set('@indent', [:indent]) Walker.new(nil, [formatter]).visit_multiline_arg(self) Lucid::Term::ANSIColor.coloring = c io.rewind s = "\n" + io.read + (" " * ([:indent] - 2)) s end |
#to_sexp ⇒ Object
For testing only
202 203 204 |
# File 'lib/lucid/ast/table.rb', line 202 def to_sexp #:nodoc: [:table, *cells_rows.map{|row| row.to_sexp}] end |
#to_step_definition_arg ⇒ Object
86 87 88 |
# File 'lib/lucid/ast/table.rb', line 86 def to_step_definition_arg dup end |
#transpose ⇒ Object
Returns a new, transposed table. Example:
| a | 7 | 4 |
| b | 9 | 2 |
Gets converted into the following:
| a | b |
| 7 | 9 |
| 4 | 2 |
107 108 109 |
# File 'lib/lucid/ast/table.rb', line 107 def transpose self.class.new(raw.transpose, @conversion_procs.dup, @header_mappings.dup, @header_conversion_proc) end |
#verify_column(column_name) ⇒ Object
:nodoc:
396 397 398 |
# File 'lib/lucid/ast/table.rb', line 396 def verify_column(column_name) #:nodoc: raise %{The column named "#{column_name}" does not exist} unless raw[0].include?(column_name) end |
#verify_table_width(width) ⇒ Object
:nodoc:
400 401 402 |
# File 'lib/lucid/ast/table.rb', line 400 def verify_table_width(width) #:nodoc: raise %{The table must have exactly #{width} columns} unless raw[0].size == width end |