class Workbook::Row
Attributes
Public Class Methods
Initialize a new row
@param [Workbook::Row, Array<Workbook::Cell>, Array] cells list of cells to initialize the row with, default is empty @param [Workbook::Table] table a row normally belongs to a table, reference it here @param [Hash] options Supported options: parse_cells_on_batch_creation (parse cell values during row-initalization, default: false), cell_parse_options (default {}, see Workbook::Modules::TypeParser
)
# File lib/workbook/row.rb, line 18 def initialize cells=[], table=nil, options={} options=options ? {:parse_cells_on_batch_creation=>false,:cell_parse_options=>{},:clone_cells=>false}.merge(options) : {} cells = [] if cells==nil self.table= table cells.each do |c| if c.is_a? Workbook::Cell c = c.clone if options[:clone_cells] else c = Workbook::Cell.new(c, {row:self}) c.parse!(options[:cell_parse_options]) if options[:parse_cells_on_batch_creation] end push c end end
Public Instance Methods
plus @param [Workbook::Row, Array] row to add @return [Workbook::Row] a new row, not linked to the table
# File lib/workbook/row.rb, line 82 def +(row) rv = super(row) rv = Workbook::Row.new(rv) unless rv.class == Workbook::Row return rv end
Add cell @param [Workbook::Cell, Numeric,String,Time,Date,TrueClass,FalseClass,NilClass] cell or value to add
# File lib/workbook/row.rb, line 74 def <<(cell) cell = Workbook::Cell.new(cell, {row:self}) unless cell.class == Workbook::Cell super(cell) end
Compares one row wiht another
@param [Workbook::Row] other row to compare against @return [Workbook::Row] a row with the diff result.
# File lib/workbook/row.rb, line 254 def <=> other a = self.header? ? 0 : 1 b = other.header? ? 0 : 1 return (a <=> b) if (a==0 or b==0) compare_without_header other end
Overrides normal Array's []-function with support for symbols that identify a column based on the header-values and / or
@example Lookup using fixnum or header value encoded as symbol
row[1] #=> <Cell value="a"> row["A"] #=> <Cell value="a"> row[:a] #=> <Cell value="a">
@param [Fixnum, Symbol, String] index_or_hash that identifies the column (strings are converted to symbols) @return [Workbook::Cell, nil]
# File lib/workbook/row.rb, line 106 def [](index_or_hash) if index_or_hash.is_a? Symbol rv = nil begin rv = to_hash[index_or_hash] rescue NoMethodError end return rv elsif index_or_hash.is_a? String and index_or_hash.match(/^[A-Z]*$/) # it looks like a column indicator return to_a[Workbook::Column.alpha_index_to_number_index(index_or_hash)] elsif index_or_hash.is_a? String symbolized = Workbook::Cell.new(index_or_hash, {row:self}).to_sym self[symbolized] else if index_or_hash return to_a[index_or_hash] end end end
Overrides normal Array's []=-function with support for symbols that identify a column based on the header-values
@example Lookup using fixnum or header value encoded as symbol (strings are converted to symbols)
row[1] #=> <Cell value="a"> row[:a] #=> <Cell value="a">
@param [Fixnum, Symbol, String] index_or_hash that identifies the column @param [String, Fixnum, NilClass, Date, DateTime, Time, Float] value @return [Workbook::Cell, nil]
# File lib/workbook/row.rb, line 136 def []= index_or_hash, value index = index_or_hash if index_or_hash.is_a? Symbol index = table_header_keys.index(index_or_hash) elsif index_or_hash.is_a? String and index_or_hash.match(/^[A-Z]*$/) # it looks like a column indicator index = Workbook::Column.alpha_index_to_number_index(index_or_hash) elsif index_or_hash.is_a? String symbolized = Workbook::Cell.new(index_or_hash, {row:self}).to_sym index = table_header_keys.index(symbolized) end value_celled = Workbook::Cell.new if value.is_a? Workbook::Cell value_celled = value else current_cell = self[index] if current_cell.is_a? Workbook::Cell value_celled = current_cell end value_celled.value=(value) end value_celled.row = self super(index,value_celled) end
clone the row with together with the cells
@return [Workbook::Row] a cloned copy of self with cells
# File lib/workbook/row.rb, line 277 def clone Workbook::Row.new(self, nil, {:clone_cells=>true}) end
Compact detaches the row from the table
# File lib/workbook/row.rb, line 269 def compact r = self.clone r = r.collect{|c| c unless c.nil?}.compact end
concat @param [Workbook::Row, Array] row to add @return [self] self
# File lib/workbook/row.rb, line 91 def concat(row) row = Workbook::Row.new(row) unless row.class == Workbook::Row super(row) end
Returns an array of cells allows you to find cells by a given color, normally a string containing a hex
@param [String] color a CSS-style hex-string @param [Hash] options Option :hash_keys (default true) returns row as an array of symbols @return [Array<Symbol>, Workbook::Row
<Workbook::Cell>]
# File lib/workbook/row.rb, line 167 def find_cells_by_background_color color=:any, options={} options = {:hash_keys=>true}.merge(options) cells = self.collect {|c| c if c.format.has_background_color?(color) }.compact r = Row.new cells options[:hash_keys] ? r.to_symbols : r end
Is this the first row in the table
@return [Boolean, NilClass] returns nil if it doesn't belong to a table, false when it isn't the first row of a table and true when it is.
# File lib/workbook/row.rb, line 184 def first? table != nil and self.object_id == table.first.object_id end
Returns true when the row belongs to a table and it is the header row (typically the first row)
@return [Boolean]
# File lib/workbook/row.rb, line 177 def header? table != nil and self.object_id == table_header.object_id end
The first cell of the row is considered to be the key
@return [Workbook::Cell] the key cell
# File lib/workbook/row.rb, line 264 def key first end
Returns true when all the cells in the row have values whose to_s value equals an empty string
@return [Boolean]
# File lib/workbook/row.rb, line 191 def no_values? all? {|c| c.value.to_s == ''} end
An internal function used in diffs
@return [Boolean] returns true when this row is not an actual row, but a placeholder row to 'compare' against
# File lib/workbook/row.rb, line 36 def placeholder? placeholder ? true : false end
Add cell @param [Workbook::Cell, Numeric,String,Time,Date,TrueClass,FalseClass,NilClass] cell or value to add
# File lib/workbook/row.rb, line 67 def push(cell) cell = Workbook::Cell.new(cell, {row:self}) unless cell.class == Workbook::Cell super(cell) end
Set reference to the table this row belongs to without adding the row to the table
@param [Workbook::Table] t the table this row belongs to
# File lib/workbook/row.rb, line 50 def set_table(t) @table = t end
Returns the table this row belongs to
@return [Workbook::Table] the table this row belongs to
# File lib/workbook/row.rb, line 43 def table @table if defined?(@table) end
Set reference to the table this row belongs to and add the row to this table
@param [Workbook::Table] t the table this row belongs to
# File lib/workbook/row.rb, line 57 def table= t raise ArgumentError, "table should be a Workbook::Table (you passed a #{t.class})" unless t.is_a?(Workbook::Table) or t == nil if t @table = t table.push(self) #unless table.index(self) and self.placeholder? end end
# File lib/workbook/row.rb, line 209 def table_header table.header end
# File lib/workbook/row.rb, line 213 def table_header_keys table_header.to_symbols end
Quick assessor to the book's template, if it exists
@return [Workbook::Template]
# File lib/workbook/row.rb, line 231 def template table.template if table end
Converts the row to an array of Workbook::Cell's @return [Array<Workbook::Cell>] returns row as an array of symbols
# File lib/workbook/row.rb, line 205 def to_a self.collect{|c| c} end
Returns a hash representation of this row
@return [Hash]
# File lib/workbook/row.rb, line 220 def to_hash keys = table_header_keys values = self hash = {} keys.each_with_index {|k,i| hash[k]=values[i]} return hash end
Returns a hash representation of this row
it differs from to_hash
as it doesn't contain the Workbook's Workbook::Cell-objects, but the actual values contained in these cells
@return [Hash]
# File lib/workbook/row.rb, line 242 def to_hash_with_values keys = table_header_keys values = self @hash_with_values = {} keys.each_with_index {|k,i| v=values[i]; v=v.value if v; @hash_with_values[k]=v} return @hash_with_values end
Converts a row to an array of symbol representations of the row content, see also: Workbook::Cell#to_sym
@return [Array<Symbol>] returns row as an array of symbols
# File lib/workbook/row.rb, line 197 def to_symbols fetch_cache(:to_symbols){ collect{|c| c.to_sym} } end
remove all the trailing nil-cells (returning a trimmed clone)
@param [Integer] desired_length of the new row @return [Workbook::Row] a trimmed clone of the array
# File lib/workbook/row.rb, line 285 def trim(desired_length=nil) self.clone.trim!(desired_length) end
remove all the trailing nil-cells (returning a trimmed self)
@param [Integer] desired_length of the new row @return [Workbook::Row] self
# File lib/workbook/row.rb, line 293 def trim!(desired_length=nil) self_count = self.count-1 self.count.times do |index| index = self_count - index if desired_length and index < desired_length break elsif desired_length and index >= desired_length self.delete_at(index) elsif self[index].nil? self.delete_at(index) else break end end (desired_length - self.count).times{|a| self << (Workbook::Cell.new(nil))} if desired_length and (desired_length - self.count) > 0 self end