class Workbook::Row

Attributes

format[RW]
placeholder[RW]

Public Class Methods

new(cells=[], table=nil, options={}) click to toggle source

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

+(row) click to toggle source

plus @param [Workbook::Row, Array] row to add @return [Workbook::Row] a new row, not linked to the table

Calls superclass method
# 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
<<(cell) click to toggle source

Add cell @param [Workbook::Cell, Numeric,String,Time,Date,TrueClass,FalseClass,NilClass] cell or value to add

Calls superclass method
# File lib/workbook/row.rb, line 74
def <<(cell)
  cell = Workbook::Cell.new(cell,  {row:self}) unless cell.class == Workbook::Cell
  super(cell)
end
<=>(other) click to toggle source

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
Also aliased as: compare_without_header
[](index_or_hash) click to toggle source

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
[]=(index_or_hash, value) click to toggle source

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]

Calls superclass method
# 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() click to toggle source

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() click to toggle source

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
compare_without_header(other)
Alias for: <=>
concat(row) click to toggle source

concat @param [Workbook::Row, Array] row to add @return [self] self

Calls superclass method
# File lib/workbook/row.rb, line 91
def concat(row)
  row = Workbook::Row.new(row) unless row.class == Workbook::Row
  super(row)
end
find_cells_by_background_color(color=:any, options={}) click to toggle source

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
first?() click to toggle source

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
header?() click to toggle source

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
key() click to toggle source

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
no_values?() click to toggle source

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
placeholder?() click to toggle source

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
push(cell) click to toggle source

Add cell @param [Workbook::Cell, Numeric,String,Time,Date,TrueClass,FalseClass,NilClass] cell or value to add

Calls superclass method
# 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_table(t) click to toggle source

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
table() click to toggle source

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
table=(t) click to toggle source

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
table_header() click to toggle source
# File lib/workbook/row.rb, line 209
def table_header
  table.header
end
table_header_keys() click to toggle source
# File lib/workbook/row.rb, line 213
def table_header_keys
  table_header.to_symbols
end
template() click to toggle source

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
to_a() click to toggle source

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
to_hash() click to toggle source

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
to_hash_with_values() click to toggle source

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
to_symbols() click to toggle source

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
trim(desired_length=nil) click to toggle source

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
trim!(desired_length=nil) click to toggle source

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