spreadbase 0.1.2 → 0.3.0

data/lib/spreadbase/codecs/open_document_12_modules/encoding.rb

@@ -1,27 +1,6 @@
-# encoding: UTF-8
-
-=begin
-Copyright 2012 Saverio Miroddi saverio.pub2 <a-hat!> gmail.com
-
-This file is part of SpreadBase.
-
-SpreadBase is free software: you can redistribute it and/or modify it under the
-terms of the GNU Lesser General Public License as published by the Free Software
-Foundation, either version 3 of the License, or (at your option) any later
-version.
-
-SpreadBase is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with SpreadBase.  If not, see <http://www.gnu.org/licenses/>.
-=end
-
 require 'rexml/document'
 require 'date'
 require 'bigdecimal'
-require 'iconv' if RUBY_VERSION < '1.9'
 
 module SpreadBase # :nodoc:
 
@@ -81,17 +60,17 @@ module SpreadBase # :nodoc:
 
         # Returns the XML root node
         #
-        def encode_to_document_node( el_document, options={} )
-          root_node        = REXML::Document.new( BASE_CONTENT_XML )
-          spreadsheet_node = root_node.elements[ '//office:document-content/office:body/office:spreadsheet' ]
-          styles_node      = root_node.elements[ '//office:document-content/office:automatic-styles'        ]
+        def encode_to_document_node(el_document)
+          root_node        = REXML::Document.new(BASE_CONTENT_XML)
+          spreadsheet_node = root_node.elements['//office:document-content/office:body/office:spreadsheet']
+          styles_node      = root_node.elements['//office:document-content/office:automatic-styles']
 
           el_document.column_width_styles.each do | style_name, column_width |
-            encode_style( styles_node, style_name, column_width )
+            encode_style(styles_node, style_name, column_width)
           end
 
           el_document.tables.each do | table |
-            encode_table( table, spreadsheet_node, options )
+            encode_table(table, spreadsheet_node)
           end
 
           root_node
@@ -99,91 +78,83 @@ module SpreadBase # :nodoc:
 
         # Currently only encodes column width styles
         #
-        def encode_style( styles_node, style_name, column_width )
-          style_node = styles_node.add_element( 'style:style', 'style:name' => style_name, 'style:family' => 'table-column' )
+        def encode_style(styles_node, style_name, column_width)
+          style_node = styles_node.add_element('style:style', 'style:name' => style_name, 'style:family' => 'table-column')
 
-          style_node.add_element( 'style:table-column-properties', 'style:column-width' => column_width )
+          style_node.add_element('style:table-column-properties', 'style:column-width' => column_width)
         end
 
-        def encode_table( table, spreadsheet_node, options={} )
-          table_node = spreadsheet_node.add_element( 'table:table' )
+        def encode_table(table, spreadsheet_node)
+          table_node = spreadsheet_node.add_element('table:table')
 
-          table_node.attributes[ 'table:name' ] = table.name
+          table_node.attributes['table:name'] = table.name
 
           table.column_width_styles.each do | style_name |
-            encode_column( table_node, style_name ) if style_name
+            encode_column(table_node, style_name) if style_name
           end
 
           # At least one column element is required
           #
-          table_node.add_element( 'table:table-column' ) if table.column_width_styles.size == 0
+          table_node.add_element('table:table-column') if table.column_width_styles.size == 0
 
-          table.data.each do | row |
-            encode_row( row, table_node, options )
+          table.data(as_cell: true).each do | row |
+            encode_row(row, table_node)
           end
         end
 
         # Currently only encodes column width styles
         #
-        def encode_column( table_node, style_name )
-          table_node.add_element( 'table:table-column', 'table:style-name' => style_name )
+        def encode_column(table_node, style_name)
+          table_node.add_element('table:table-column', 'table:style-name' => style_name)
         end
 
-        def encode_row( row, table_node, options={} )
-          row_node = table_node.add_element( 'table:table-row' )
+        def encode_row(row, table_node)
+          row_node = table_node.add_element('table:table-row')
 
-          row.each do | value |
-            encode_cell( value, row_node, options )
+          row.each do | cell |
+            encode_cell(cell.value, row_node)
           end
         end
 
-        def encode_cell( value, row_node, options={} )
-          force_18_strings_encoding = options[ :force_18_strings_encoding ] || 'UTF-8'
-
-          cell_node = row_node.add_element( 'table:table-cell' )
+        def encode_cell(value, row_node)
+          cell_node = row_node.add_element('table:table-cell')
 
           # WATCH OUT!!! DateTime.new.is_a?( Date )!!!
           #
           case value
           when String
-            cell_node.attributes[ 'office:value-type' ] = 'string'
-
-            cell_value_node = cell_node.add_element( 'text:p' )
+            cell_node.attributes['office:value-type'] = 'string'
 
-            if RUBY_VERSION >= '1.9'
-              value = value.encode( 'UTF-8' )
-            else
-              value = Iconv.conv( 'UTF-8', force_18_strings_encoding, value )
-            end
+            cell_value_node = cell_node.add_element('text:p')
 
-            cell_value_node.text = value
+            cell_value_node.text = value.encode('UTF-8')
           when Time, DateTime
-            cell_node.attributes[ 'office:value-type' ] = 'date'
-            cell_node.attributes[ 'table:style-name'  ] = 'datetime'
+            cell_node.attributes['office:value-type'] = 'date'
+            cell_node.attributes['table:style-name'] = 'datetime'
 
-            encoded_value = value.strftime( '%Y-%m-%dT%H:%M:%S' )
+            encoded_value = value.strftime('%Y-%m-%dT%H:%M:%S')
 
-            cell_node.attributes[ 'office:date-value' ] = encoded_value
+            cell_node.attributes['office:date-value'] = encoded_value
           when Date
-            cell_node.attributes[ 'office:value-type' ] = 'date'
-            cell_node.attributes[ 'table:style-name'  ] = 'date'
+            cell_node.attributes['office:value-type'] = 'date'
+            cell_node.attributes['table:style-name'] = 'date'
 
-            encoded_value = value.strftime( '%Y-%m-%d' )
+            encoded_value = value.strftime('%Y-%m-%d')
 
-            cell_node.attributes[ 'office:date-value' ] = encoded_value
+            cell_node.attributes['office:date-value'] = encoded_value
           when BigDecimal
-            cell_node.attributes[ 'office:value-type' ] = 'float'
+            cell_node.attributes['office:value-type'] = 'float'
 
-            cell_node.attributes[ 'office:value' ] = value.to_s( 'F' )
-          when Float, Fixnum
-            cell_node.attributes[ 'office:value-type' ] = 'float'
+            cell_node.attributes['office:value'] = value.to_s('F')
+          when Float, Integer
+            cell_node.attributes['office:value-type'] = 'float'
 
-            cell_node.attributes[ 'office:value' ] = value.to_s
+            cell_node.attributes['office:value'] = value.to_s
           when true, false
-            cell_node.attributes[ 'office:value-type' ] = 'boolean'
-            cell_node.attributes[ 'table:style-name'  ] = 'boolean'
+            cell_node.attributes['office:value-type'] = 'boolean'
+            cell_node.attributes['table:style-name'] = 'boolean'
 
-            cell_node.attributes[ 'office:boolean-value' ] = value.to_s
+            cell_node.attributes['office:boolean-value'] = value.to_s
           when nil
             # do nothing
           else

data/lib/spreadbase/document.rb

@@ -1,23 +1,3 @@
-# encoding: UTF-8
-
-=begin
-Copyright 2012 Saverio Miroddi saverio.pub2 <a-hat!> gmail.com
-
-This file is part of SpreadBase.
-
-SpreadBase is free software: you can redistribute it and/or modify it under the
-terms of the GNU Lesser General Public License as published by the Free Software
-Foundation, either version 3 of the License, or (at your option) any later
-version.
-
-SpreadBase is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with SpreadBase.  If not, see <http://www.gnu.org/licenses/>.
-=end
-
 module SpreadBase # :nodoc:
 
   # Represents the abstraction of a document, merging both the file and the
@@ -42,16 +22,15 @@ module SpreadBase # :nodoc:
     #
     # _options_:
     #
-    # +force_18_strings_encoding+::   ('UTF-8') on ruby 1.8, when converting to UTF-8, assume the strings are using the specified format.
     # +floats_as_bigdecimal+::        (false) decode floats as BigDecimal instead of Float
     #
-    def initialize( document_path=nil, options={} )
+    def initialize(document_path=nil, options={})
       @document_path = document_path
       @options       = options.clone
 
-      if @document_path && File.exists?( document_path )
-        document_archive = IO.read( document_path )
-        decoded_document = Codecs::OpenDocument12.new.decode_archive( document_archive, options )
+      if @document_path && File.exist?(document_path)
+        document_archive = IO.read(document_path)
+        decoded_document = Codecs::OpenDocument12.new.decode_archive(document_archive, options)
 
         @column_width_styles = decoded_document.column_width_styles
         @tables              = decoded_document.tables
@@ -69,28 +48,28 @@ module SpreadBase # :nodoc:
     #
     # +prettify+::                   Prettifies the content.xml file before saving.
     #
-    def save( options={} )
-      options = @options.merge( options )
+    def save(options={})
+      options = @options.merge(options)
 
       raise "At least one table must be present" if @tables.empty?
       raise "Document path not specified"        if @document_path.nil?
 
-      document_archive = Codecs::OpenDocument12.new.encode_to_archive( self, options )
+      document_archive = Codecs::OpenDocument12.new.encode_to_archive(self, options)
 
-      File.open( @document_path, 'wb' ) { | file | file << document_archive }
+      File.open(@document_path, 'wb') { | file | file << document_archive }
     end
 
     # _options_:
     #
     # +with_headers+::        Print the tables with headers.
     #
-    def to_s( options={} )
-      options.merge!( :row_prefix => '  ' )
+    def to_s(options={})
+      options.merge!(row_prefix: '  ')
 
-      tables.inject( '' ) do | output, table |
+      tables.inject('') do | output, table |
         output << "#{ table.name }:" << "\n" << "\n"
 
-        output << table.to_s( options ) << "\n"
+        output << table.to_s(options) << "\n"
       end
     end
 

data/lib/spreadbase/helpers/helpers.rb

@@ -1,23 +1,3 @@
-# encoding: UTF-8
-
-=begin
-Copyright 2012 Saverio Miroddi saverio.pub2 <a-hat!> gmail.com
-
-This file is part of SpreadBase.
-
-SpreadBase is free software: you can redistribute it and/or modify it under the
-terms of the GNU Lesser General Public License as published by the Free Software
-Foundation, either version 3 of the License, or (at your option) any later
-version.
-
-SpreadBase is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with SpreadBase.  If not, see <http://www.gnu.org/licenses/>.
-=end
-
 module SpreadBase # :nodoc:
 
   # Currently generic helper class
@@ -28,10 +8,10 @@ module SpreadBase # :nodoc:
     #
     # The instance is duplicated Object#clone, when necessary - note that this method is not meant to do a deep copy.
     #
-    def make_array_from_repetitions( instance, repetitions )
-      ( 1 .. repetitions ).inject( [] ) do | cumulative_result, i |
+    def make_array_from_repetitions(instance, repetitions)
+      (1..repetitions).inject([]) do | cumulative_result, i |
         case instance
-        when Fixnum, Float, BigDecimal, Date, Time, TrueClass, FalseClass, NilClass #, DateTime is a Date
+        when Integer, Float, BigDecimal, Date, Time, TrueClass, FalseClass, NilClass #, DateTime is a Date
           cumulative_result << instance
         when String, Array
           cumulative_result << instance.clone
@@ -54,54 +34,49 @@ module SpreadBase # :nodoc:
     # +row_prefix+::            Prefix this string to each row.
     # +with_header+::           First row will be separated from the remaining ones.
     #
-    # +formatting_block+::      If passed, values will be formatted by the block.
-    #                           If no block is passed, or it returns nil or :standard, the standard formatting is used.
-    #
-    def pretty_print_rows( rows, options={}, &formatting_block )
-      row_prefix   = options[ :row_prefix   ] || ''
-      with_headers = options[ :with_headers ]
+    def pretty_print_rows(rows, options={})
+      row_prefix   = options[:row_prefix] || ''
+      with_headers = options[:with_headers]
 
       output = ""
 
-      formatting_block = lambda { | value | value.to_s } if ! block_given?
-
       if rows.size > 0
-        max_column_sizes = [ 0 ] * rows.map( &:size ).max
+        max_column_sizes = [0] * rows.map(&:size).max
 
         # Compute maximum widths
 
         rows.each do | values |
           values.each_with_index do | value, i |
-            formatted_value       = pretty_print_value( value, &formatting_block )
+            formatted_value       = pretty_print_value(value)
             formatted_value_width = formatted_value.chars.to_a.size
 
-            max_column_sizes[ i ] = formatted_value_width if formatted_value_width > max_column_sizes[ i ]
+            max_column_sizes[i] = formatted_value_width if formatted_value_width > max_column_sizes[i]
           end
         end
 
         # Print!
 
-        output << row_prefix << '+-' + max_column_sizes.map { | size | '-' * size }.join( '-+-' ) + '-+' << "\n"
+        output << row_prefix << '+-' + max_column_sizes.map { | size | '-' * size }.join('-+-') + '-+' << "\n"
 
-        print_pattern = '| ' + max_column_sizes.map { | size | "%-#{ size }s" }.join( ' | ' ) + ' |'
+        print_pattern = '| ' + max_column_sizes.map { | size | "%-#{ size }s" }.join(' | ') + ' |'
 
         rows.each_with_index do | row, row_index |
           # Ensure that we always have a number of values equal to the max width
           #
-          formatted_row_values = ( 0 ... max_column_sizes.size ).map do | column_index |
-            value = row[ column_index ]
+          formatted_row_values = (0...max_column_sizes.size).map do | column_index |
+            value = row[column_index]
 
-            pretty_print_value( value, &formatting_block )
+            pretty_print_value(value)
           end
 
           output << row_prefix << print_pattern % formatted_row_values << "\n"
 
           if with_headers && row_index == 0
-            output << row_prefix << '+-' + max_column_sizes.map { | size | '-' * size }.join( '-+-' ) + '-+' << "\n"
+            output << row_prefix << '+-' + max_column_sizes.map { | size | '-' * size }.join('-+-') + '-+' << "\n"
           end
         end
 
-        output << row_prefix << '+-' + max_column_sizes.map { | size | '-' * size }.join( '-+-' ) + '-+' << "\n"
+        output << row_prefix << '+-' + max_column_sizes.map { | size | '-' * size }.join('-+-') + '-+' << "\n"
       end
 
       output
@@ -109,27 +84,18 @@ module SpreadBase # :nodoc:
 
     private
 
-    def pretty_print_value( value, &formatting_block )
-      custom_result = block_given? && yield( value )
-
-      if custom_result && custom_result != :standard
-        custom_result
+    def pretty_print_value(value)
+      case value
+      when BigDecimal
+        value.to_s('F')
+      when Time, DateTime
+        value.strftime('%Y-%m-%d %H:%M:%S %z')
+      when String, Date, Numeric, TrueClass, FalseClass
+        value.to_s
+      when nil
+        "NIL"
       else
-        case value
-        when BigDecimal
-          value.to_s( 'F' )
-        when Time, DateTime
-          # Time#to_s renders differently between 1.8.7 and 1.9.3; 1.8.7's rendering is bizarrely
-          # inconsistent with the Date and DateTime ones.
-          #
-          value.strftime( '%Y-%m-%d %H:%M:%S %z' )
-        when String, Date, Numeric, TrueClass, FalseClass
-          value.to_s
-        when nil
-          "NIL"
-        else
-          value.inspect
-        end
+        value.inspect
       end
     end
 

data/lib/spreadbase/table.rb

@@ -1,23 +1,3 @@
-# encoding: UTF-8
-
-=begin
-Copyright 2012 Saverio Miroddi saverio.pub2 <a-hat!> gmail.com
-
-This file is part of SpreadBase.
-
-SpreadBase is free software: you can redistribute it and/or modify it under the
-terms of the GNU Lesser General Public License as published by the Free Software
-Foundation, either version 3 of the License, or (at your option) any later
-version.
-
-SpreadBase is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
-PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License along
-with SpreadBase.  If not, see <http://www.gnu.org/licenses/>.
-=end
-
 module SpreadBase # :nodoc:
 
   # Represents the abstraction of a table and its contents.
@@ -32,7 +12,7 @@ module SpreadBase # :nodoc:
 
     include SpreadBase::Helpers
 
-    attr_accessor :name, :data
+    attr_accessor :name
 
     # Array of style names; nil when not associated to any column width.
     #
@@ -41,16 +21,24 @@ module SpreadBase # :nodoc:
     # _params_:
     #
     # +name+::                       (required) Name of the table
-    # +data+::                       (Array.new) 2d matrix of the data. if not empty, the rows need to be all of the same size
+    # +raw_data+::                   (Array.new) 2d matrix of the data. if not empty, the rows need to be all of the same size
     #
-    def initialize( name, data=[] )
+    def initialize(name, raw_data=[])
       raise "Table name required" if name.nil? || name == ''
 
       @name                = name
-      @data                = data
+      self.data            = raw_data
       @column_width_styles = []
     end
 
+    def data=(the_data)
+      @data = the_data.map { | the_row | array_to_cells(the_row) }
+    end
+
+    def data(options={})
+      @data.map { | the_row | the_row.map { | cell | cell_to_value(cell, options) } }
+    end
+
     # Access a cell value.
     #
     # _params_:
@@ -60,13 +48,14 @@ module SpreadBase # :nodoc:
     #
     # _returns_ the value, which is automatically converted to the Ruby data type.
     #
-    def []( column_identifier, row_index )
-      row          = row( row_index )
-      column_index = decode_column_identifier( column_identifier )
+    def [](column_identifier, row_index, options={})
+      the_row = row(row_index, options)
 
-      check_column_index( row, column_index )
+      column_index = decode_column_identifier(column_identifier)
 
-      row[ column_index ]
+      check_column_index(the_row, column_index)
+
+      the_row[column_index]
     end
 
     # Writes a value in a cell.
@@ -77,25 +66,31 @@ module SpreadBase # :nodoc:
     # +row_index+::                  int (0-based). see notes about the rows indexing.
     # +value+::                      value
     #
-    def []=( column_identifier, row_index, value )
-      row          = row( row_index )
-      column_index = decode_column_identifier( column_identifier )
+    def []=(column_identifier, row_index, value)
+      check_row_index(row_index)
+
+      the_row      = @data[row_index]
+      column_index = decode_column_identifier(column_identifier)
 
-      check_column_index( row, column_index )
+      check_column_index(the_row, column_index)
 
-      row[ column_index ] = value
+      the_row[column_index] = value_to_cell(value)
     end
 
     # Returns an array containing the values of a single row.
     #
     # _params_:
     #
-    # +row_index+::                  int (0-based). see notes about the rows indexing.
+    # +row_index+::                  int or range (0-based). see notes about the rows indexing.
     #
-    def row( row_index )
-      check_row_index( row_index )
+    def row(row_index, options={})
+      check_row_index(row_index)
 
-      @data[ row_index ]
+      if row_index.is_a?(Range)
+        @data[row_index].map { | row | cells_to_array(row, options) }
+      else
+        cells_to_array(@data[row_index], options)
+      end
     end
 
     # Deletes a row.
@@ -104,14 +99,20 @@ module SpreadBase # :nodoc:
     #
     # _params_:
     #
-    # +row_index+::                  int (0-based). see notes about the rows indexing.
+    # +row_index+::                  int or range (0-based). see notes about the rows indexing.
     #
-    # _returns_ the deleted row
+    # _returns_ the deleted row[s]
     #
-    def delete_row( row_index )
-      check_row_index( row_index )
+    def delete_row(row_index)
+      check_row_index(row_index)
 
-      @data.slice!( row_index )
+      deleted_cells = @data.slice!(row_index)
+
+      if row_index.is_a?(Range)
+        deleted_cells.map { | row | cells_to_array(row) }
+      else
+        cells_to_array(deleted_cells)
+      end
     end
 
     # Inserts a row.
@@ -123,16 +124,18 @@ module SpreadBase # :nodoc:
     # +row_index+::                  int (0-based). must be between 0 and (including) the table rows size.
     # +row+::                        array of values. if the table is not empty, must have the same size of the table width.
     #
-    def insert_row( row_index, row )
-      check_row_index( row_index, :allow_append => true )
+    def insert_row(row_index, row)
+      check_row_index(row_index, allow_append: true)
 
-      @data.insert( row_index, row )
+      cells = array_to_cells(row)
+
+      @data.insert(row_index, cells)
     end
 
     # This operation won't modify the column width styles in any case.
     #
-    def append_row( row )
-      insert_row( @data.size, row )
+    def append_row(row)
+      insert_row(@data.size, row)
     end
 
     # Returns an array containing the values of a single column.
@@ -141,35 +144,68 @@ module SpreadBase # :nodoc:
     #
     # _params_:
     #
-    # +column_indentifier+::         either an int (0-based) or the excel-format identifier (AA...).
+    # +column_indentifier+::         for single access, us either an int (0-based) or the excel-format identifier (AA...).
     #                                when int, follow the same idea of the rows indexing (ruby semantics).
+    #                                for multiple access, use a range either of int or excel-format identifiers - pay attention, because ( 'A'..'c' ) is not semantically correct.
+    #                                interestingly, ruby letter ranges convention is the same as the excel columns one.
     #
-    def column( column_identifier )
-      column_index = decode_column_identifier( column_identifier )
+    def column(column_identifier, options={})
+      if column_identifier.is_a?(Range)
+        min_index = decode_column_identifier(column_identifier.min)
+        max_index = decode_column_identifier(column_identifier.max)
+
+        (min_index..max_index).map do | column_index |
+          @data.map do | the_row |
+            cell = the_row[column_index]
+
+            cell_to_value(cell, options)
+          end
+        end
+      else
+        column_index = decode_column_identifier(column_identifier)
 
-      @data.map do | row |
-        row[ column_index ]
+        @data.map do | the_row |
+          cell = the_row[column_index]
+
+          cell_to_value(cell, options)
+        end
       end
     end
 
     # Deletes a column.
     #
-    # WATCH OUT! This method doesn't have the range restrictions that axis indexes generally has, that is, it's possible to delete a column outside the boundaries of the rows - it will return nil for each of those values.
+    # See Table#column for the indexing notes.
     #
     # _params_:
     #
-    # +column_indentifier+::         either an int (0-based) or the excel-format identifier (AA...).
-    #                                when int, follow the same idea of the rows indexing (ruby semantics).
+    # +column_indentifier+::         See Table#column
     #
     # _returns_ the deleted column
     #
-    def delete_column( column_identifier )
-      column_index = decode_column_identifier( column_identifier )
+    def delete_column(column_identifier)
+      if column_identifier.is_a?(Range)
+        min_index = decode_column_identifier(column_identifier.min)
+        max_index = decode_column_identifier(column_identifier.max)
 
-      @column_width_styles.slice!( column_index )
+        reverse_result = max_index.downto(min_index).map do | column_index |
+          @data.map do | row |
+            cell = row.slice!(column_index)
 
-      @data.map do | row |
-        row.slice!( column_index )
+            cell_to_value(cell)
+          end
+        end
+
+        reverse_result.reverse
+      else
+        column_index = decode_column_identifier(column_identifier)
+
+        @column_width_styles.slice!(column_index)
+
+        @data.map do | row |
+          cell = row.slice!(column_index)
+
+          cell_to_value(cell)
+        end
       end
     end
 
@@ -183,37 +219,63 @@ module SpreadBase # :nodoc:
     #                                when int, follow the same idea of the rows indexing (ruby semantics).
     # +column+::                     array of values. if the table is not empty, it must have the same size of the table height.
     #
-    def insert_column( column_identifier, column )
+    def insert_column(column_identifier, column)
       raise "Inserting column size (#{ column.size }) different than existing columns size (#{ @data.size })" if @data.size > 0 && column.size != @data.size
 
-      column_index = decode_column_identifier( column_identifier )
+      column_index = decode_column_identifier(column_identifier)
 
-      @column_width_styles.insert( column_index, nil )
+      @column_width_styles.insert(column_index, nil)
 
       if @data.size > 0
-        @data.zip( column ).each do | row, value |
-          row.insert( column_index, value )
+        @data.zip(column).each do | row, value |
+          cell = value_to_cell(value)
+
+          row.insert(column_index, cell)
         end
       else
-        @data = column.map { | value | [ value ] }
+        @data = column.map do | value |
+          [value_to_cell(value)]
+        end
       end
 
     end
 
-    def append_column( column )
+    def append_column(column)
       column_index = @data.size > 0 ? @data.first.size : 0
 
-      insert_column( column_index, column )
+      insert_column(column_index, column)
     end
 
     # _returns_ a matrix representation of the tables, with the values being separated by commas.
     #
-    def to_s( options={} )
-      pretty_print_rows( @data, options )
+    def to_s(options={})
+      pretty_print_rows(data, options)
     end
 
     private
 
+    def array_to_cells(the_row)
+      the_row.map { | value | value_to_cell(value) }
+    end
+
+    def value_to_cell(value)
+      value.is_a?(Cell) ? value : Cell.new(value)
+    end
+
+    def cells_to_array(cells, options={})
+      cells.map { | cell | cell_to_value(cell, options) }
+    end
+
+    def cell_to_value(cell, options={})
+      as_cell = options[:as_cell]
+
+      if as_cell
+        cell
+      else
+        cell.value if cell
+      end
+    end
+
     # Check that row index points to an existing record, or, in case of :allow_append,
     # point to one unit above the last row.
     #
@@ -221,15 +283,17 @@ module SpreadBase # :nodoc:
     #
     # +allow_append+::      Allow pointing to one unit above the last row.
     #
-    def check_row_index( row_index, options={} )
-      allow_append = options [ :allow_append ]
+    def check_row_index(row_index, options={})
+      allow_append = options [:allow_append]
 
       positive_limit = allow_append ? @data.size : @data.size - 1
 
+      row_index = row_index.max if row_index.is_a?(Range)
+
       raise "Invalid row index (#{ row_index }) - allowed 0 to #{ positive_limit }" if row_index < 0 || row_index > positive_limit
     end
 
-    def check_column_index( row, column_index )
+    def check_column_index(row, column_index)
       raise "Invalid column index (#{ column_index }) for the given row - allowed 0 to #{ row.size - 1 }" if column_index >= row.size
     end
 
@@ -238,12 +302,9 @@ module SpreadBase # :nodoc:
     # Raises an error for invalid identifiers/indexes.
     #
     # _returns_ a 0-based decimal number.
-    #--
-    # Motherf#### base-26 bijective numeration - I would have gladly saved my f* time. At least
-    # there were a few cute ladies at the Charleston lesson.
     #
-    def decode_column_identifier( column_identifier )
-      if column_identifier.is_a?( Fixnum )
+    def decode_column_identifier(column_identifier)
+      if column_identifier.is_a?(Integer)
         raise "Negative column indexes not allowed: #{ column_identifier }" if column_identifier < 0
 
         column_identifier
@@ -253,9 +314,9 @@ module SpreadBase # :nodoc:
 
         raise "Invalid letter for in column identifier (allowed 'a/A' to 'z/Z')" if letters.any? { | letter | letter < 'A' || letter > 'Z' }
 
-        base_10_value = letters.inject( 0 ) do | sum, letter |
-          letter_ord = letter.unpack( 'C' ).first
-          sum * 26 + ( letter_ord - upcase_a_ord + 1 )
+        base_10_value = letters.inject(0) do | sum, letter |
+          letter_ord = letter.unpack('C').first
+          sum * 26 + (letter_ord - upcase_a_ord + 1)
         end
 
         base_10_value -= 1