workbook 0.3.1 → 0.4

data/doc/top-level-namespace.html

@@ -6,7 +6,7 @@
 <title>
   Top Level Namespace
   
-    &mdash; Documentation by YARD 0.8.3
+    &mdash; Documentation by YARD 0.8.5.2
   
 </title>
 
@@ -103,9 +103,9 @@
 </div>
 
     <div id="footer">
-  Generated on Thu Jan 17 13:15:56 2013 by
+  Generated on Sun May  5 14:58:04 2013 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.8.3 (ruby-1.8.7).
+  0.8.5.2 (ruby-1.9.3).
 </div>
 
   </body>

data/lib/workbook/book.rb

@@ -1,8 +1,10 @@
 # -*- encoding : utf-8 -*-
 require 'workbook/writers/xls_writer'
+require 'workbook/writers/html_writer'
 require 'workbook/readers/xls_reader'
 require 'workbook/readers/xls_shared'
 require 'workbook/readers/xlsx_reader'
+require 'workbook/readers/ods_reader'
 require 'workbook/readers/csv_reader'
 require 'workbook/readers/txt_reader'
 
@@ -13,10 +15,12 @@ module Workbook
   class Book < Array
     include Workbook::Readers::XlsShared
     include Workbook::Writers::XlsWriter
+    include Workbook::Writers::HtmlWriter
     include Workbook::Readers::XlsReader
+    include Workbook::Readers::OdsReader
     include Workbook::Readers::XlsxReader
     include Workbook::Readers::CsvReader
-    include Workbook::Readers::TxtReader    
+    include Workbook::Readers::TxtReader
     
     attr_accessor :title
     attr_accessor :template
@@ -149,6 +153,28 @@ module Workbook
       return wb
     end
 
+    # Create an instance from the given stream or string, which should be in CSV or TXT format
+    #
+    # @param [StringIO] stringio_or_string StringIO stream or String object, with data in CSV or TXT format
+    # @param [Symbol] filetype (currently only :csv or :txt), indicating the format of the first parameter
+    # @return [Workbook::Book] A new instance
+    def self.read(stringio_or_string, filetype)
+      wb = self.new
+      wb.read(stringio_or_string, filetype)
+      wb
+    end
+    
+    # Load the CSV data contained in the given StringIO or String object
+    #
+    # @param [StringIO] stringio_or_string StringIO stream or String object, with data in CSV format
+    # @param [Symbol] filetype (currently only :csv or :txt), indicating the format of the first parameter
+    def read(stringio_or_string, filetype)
+      raise ArgumentError.new("The filetype parameter should be either :csv or :txt") unless [:csv, :txt].include?(filetype)
+      t = stringio_or_string.respond_to?(:read) ? stringio_or_string.read : stringio_or_string.to_s
+      t = text_to_utf8(t)
+      send(:"parse_#{filetype}", t)
+    end
+
     # Create or open the existing sheet at an index value
     # 
     # @param [Integer] index    the index of the sheet

data/lib/workbook/format.rb

@@ -6,38 +6,77 @@ module Workbook
   class Format < Hash
     include Workbook::Modules::RawObjectsStorage
     alias_method :merge_hash, :merge
+    alias_method :merge_hash!, :merge!
     
-    attr_accessor :name
+    attr_accessor :name, :parent
     
     # Initialize
     # @param [Workbook::Format, Hash] options (e.g. :background, :color
-    def initialize options={}
+    def initialize options={}, name=nil
       options.each {|k,v| self[k]=v}
+      self.name = name
     end
     
     # Does the current format feature a background *color*? (not black or white or transparant).
     def has_background_color? color=:any
-      if self[:background_color]
-        return (self[:background_color].downcase==color.to_s.downcase or (!(self[:background_color]==nil or (self[:background_color].is_a? String and (self[:background_color].downcase=='#ffffff' or self[:background_color]=='#000000'))) and color==:any))
+      if flattened[:background_color]
+        return (flattened[:background_color].downcase==color.to_s.downcase or (!(flattened[:background_color]==nil or (flattened[:background_color].is_a? String and (flattened[:background_color].downcase=='#ffffff' or flattened[:background_color]=='#000000'))) and color==:any))
       else
         return false
       end
     end
     
     # Returns a string that can be used as inline cell styling (e.g. `<td style="<%=cell.format.to_css%>"><%=cell%></td>`)
-    # @return [String] very basic CSS styling string
+    # @return String very basic CSS styling string
     def to_css
       css_parts = []
-      css_parts.push("background: #{self[:background_color].to_s} #{self[:background].to_s}".strip) if self[:background] or self[:background_color]
-      css_parts.push("color: #{self[:color].to_s}") if self[:color]
+      background = [flattened[:background_color].to_s,flattened[:background].to_s].join(" ").strip
+      css_parts.push("background: #{background}") if background and background != ""
+      css_parts.push("color: #{flattened[:color].to_s}") if flattened[:color]
       css_parts.join("; ")
     end
     
     # Combines the formatting options of one with another, removes as a consequence the reference to the raw object's equivalent.
     # @param [Workbook::Format] other_format
+    # @return [Workbook::Format] a new resulting Workbook::Format
     def merge(other_format)
       self.remove_all_raws!
       self.merge_hash(other_format)
     end
+    
+    # Applies the formatting options of self with another, removes as a consequence the reference to the raw object's equivalent.
+    # @param [Workbook::Format] other_format 
+    # @return [Workbook::Format] self
+    def merge!(other_format)
+      self.remove_all_raws!
+      self.merge_hash!(other_format)
+    end
+    
+    # returns an array of all formats this style is inheriting from (including itself)
+    # @return [Array<Workbook::Format>] an array of Workbook::Formats
+    def formats
+      formats=[]
+      f = self
+      formats << f
+      while f.parent
+        formats << f.parent
+        f = f.parent
+      end
+      formats.reverse
+    end
+    
+    # returns an array of all format-names this style is inheriting from (and this style)
+    # @return [Array<String>] an array of Workbook::Formats
+    def all_names 
+      formats.collect{|a| a.name}
+    end
+    
+    # Applies the formatting options of self with its parents until no parent can be found
+    # @return [Workbook::Format] new Workbook::Format that is the result of merging current style with all its parent's styles.
+    def flattened
+      ff=Workbook::Format.new()
+      formats.each{|a| ff.merge!(a) }
+      return ff
+    end
   end
 end

data/lib/workbook/modules/type_parser.rb

@@ -90,9 +90,16 @@ module Workbook
               rv = v
             end
             begin
-              rv = Date.parse(v.to_i.to_s) == rv ? v : rv # disqualify is it is only based on the first number
+              rv = Date.parse(v.to_i.to_s) == rv ? v : rv # disqualify if it is only based on the first number
             rescue ArgumentError
             end
+            # try strptime with format 'mm/dd/yyyy'
+            if rv == v && /^\d{1,2}[\/-]\d{1,2}[\/-]\d{4}/ =~ v
+              begin
+                rv = Date.strptime(v, "%m/%d/%Y")
+              rescue ArgumentError
+              end
+            end
           end          
           rv
         end

data/lib/workbook/readers/ods_reader.rb

@@ -0,0 +1,93 @@
+# -*- encoding : utf-8 -*-
+
+module Workbook
+  module Readers
+    module OdsReader
+      
+      # reads self with and ods-type content.xml
+      # @param [String,File] file_obj a file or file reference
+      # @return [Workbook::Book] self
+      def load_ods file_obj
+        file_obj = file_obj.path if file_obj.is_a? File
+        content = ""
+        styles = ""
+        Zip::ZipFile.open(file_obj) do |zipfile|
+          zipfile.entries.each do |file|
+            styles = zipfile.read(file.name) if file.name == "styles.xml"  
+            
+            content = zipfile.read(file.name) if file.name == "content.xml"  
+          end
+        end
+        content = Nokogiri.XML(content)
+        styles = Nokogiri.XML(styles)
+        template.add_raw content
+        parse_ods_style styles
+        parse_ods content
+        return self
+      end
+      
+      def set_format_property format, property, value
+        value.strip!
+        format[property] = value if value and value != ""
+      end
+      
+      def parse_ods_style parse_ods_style
+        parse_ods_style.xpath("//style:style").each do |style|
+          style_family = style.xpath("@style:family").to_s
+          if style_family == "table-cell"
+            format = Workbook::Format.new
+            format.name = style.xpath("@style:name").to_s
+            format.parent = self.template.formats[style.xpath("@style:parent-style-name").to_s]
+            set_format_property format, :border, style.xpath("style:table-cell-properties/@fo:border").to_s
+            set_format_property format, :vertical_align, style.xpath("style:table-cell-properties/@style:vertical-align").to_s.gsub("automatic","auto")
+            set_format_property format, :padding, style.xpath("style:table-cell-properties/@fo:padding").to_s.gsub("automatic","auto")
+            set_format_property format, :font, style.xpath("style:text-properties/style:font-name").to_s + " " + style.xpath("style:text-properties/fo:font-size").to_s + " " + style.xpath("style:text-properties/fo:font-weight").to_s
+            set_format_property format, :color, style.xpath("style:text-properties/@fo:color").to_s
+            set_format_property format, :background_color, style.xpath("style:table-cell-properties/@fo:background-color").to_s
+            self.template.add_format(format)
+          end
+        end
+      end
+      
+      # updates self with and ods-type content.xml
+      # @param [Nokogiri::XML::Document] ods_spreadsheet nokogirified content.xml
+      # @return [Workbook::Book] self
+      def parse_ods ods_spreadsheet=template.raws[Nokogiri::XML::Document], options={}
+        options = {:additional_type_parsing=>false}.merge options
+        # styles
+        #puts ods_spreadsheet
+        parse_ods_style ods_spreadsheet
+        
+        # data
+        ods_spreadsheet.xpath("//office:body/office:spreadsheet").each_with_index do |sheet,sheetindex|
+          s = self.create_or_open_sheet_at(sheetindex)
+          sheet.xpath("table:table").each_with_index do |table,tableindex|
+            t = s.create_or_open_table_at(tableindex)
+            table.xpath("table:table-row").each_with_index do |row,rowindex|
+              row = row.xpath("table:table-cell").collect do |cell|
+                c = Workbook::Cell.new()
+                cell_style_name = cell.xpath('@table:style-name').to_s
+                c.format = self.template.formats[cell_style_name]
+                valuetype = cell.xpath('@office:value-type').to_s
+                value = cell.xpath("text:p//text()").to_s
+                value = value == "" ? nil : value
+                case valuetype
+                when 'float'
+                  value = cell.xpath("@office:value").to_s.to_f
+                when 'integer'
+                  value = cell.xpath("@office:value").to_s.to_i
+                when 'date'
+                  value = DateTime.parse(cell.xpath("@office:date-value").to_s)
+                end           
+                c.value = value
+                c
+              end
+              t << Workbook::Row.new(row)
+            end
+          end
+        end
+        return self
+      end
+    end
+  end
+end

data/lib/workbook/row.rb

@@ -134,6 +134,13 @@ module Workbook
       table != nil and self.object_id == table.first.object_id
     end
     
+    # Returns true when all the cells in the row have values whose to_s value equals an empty string
+    #
+    # @return [Boolean]
+    def no_values?
+      all? {|c| c.value.to_s == ''}
+    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
     def to_symbols

data/lib/workbook/sheet.rb

@@ -64,5 +64,15 @@ module Workbook
       s.each{|t| c << t.clone}
       return c
     end
+    
+    # Create or open the existing table at an index value
+    # 
+    # @param [Integer] index    the index of the table
+    def create_or_open_table_at index
+      t = self[index]
+      t = self[index] = Workbook::Table.new if t == nil
+      t.sheet = self
+      t 
+    end
   end
 end

data/lib/workbook/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module Workbook
-  VERSION = '0.3.1'
+  VERSION = '0.4'
 end

data/lib/workbook/writers/html_writer.rb

@@ -0,0 +1,56 @@
+# -*- encoding : utf-8 -*-
+require 'spreadsheet'
+
+module Workbook
+  module Writers
+    module HtmlWriter
+
+      # Generates an Spreadsheet (from the spreadsheet gem) in order to build an XlS
+      # 
+      # @param [Hash] options A hash with options
+      # @return [Spreadsheet] A Spreadsheet object, ready for writing or more lower level operations
+      def to_html options={}
+        options = {:style_with_inline_css=>false}.merge(options)
+        builder = Nokogiri::HTML::Builder.new do |doc|
+          doc.html {
+            doc.body {
+              self.each{|sheet| 
+                doc.h1 {
+                  doc.text sheet.name
+                }
+                sheet.each{|table|
+                  doc.table {
+                    table.each{|row|
+                      doc.tr {
+                        row.each {|cell|
+                          classnames = cell.format.all_names.join(" ").strip
+                          td_options = classnames != "" ? {:class=>classnames} : {}
+                          td_options = td_options.merge({:style=>cell.format.to_css}) if options[:style_with_inline_css] and cell.format.to_css != ""
+                          doc.td(td_options) {
+                            doc.text cell.value
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        end
+        return builder.to_html
+      end
+
+
+
+      # Write the current workbook to Microsoft Excel format (using the spreadsheet gem)
+      #
+      # @param [String] filename
+      # @param [Hash] options   see #to_xls 
+      def write_to_html filename="#{title}.html", options={}
+        File.open(filename, 'w') {|f| f.write(to_html(options)) }
+        return filename
+      end
+    end
+  end
+end

data/test/test_book.rb

@@ -61,4 +61,10 @@ class TestWorkbook < Test::Unit::TestCase
     t = w.text_to_utf8(t)
     assert_equal("a\tb\tc\td", t.split(/(\n|\r)/).first)
   end
+  
+  def test_read_bad_filetype
+    assert_raises(ArgumentError) { Workbook::Book.read("test string here", :xls) }
+    assert_raises(ArgumentError) { Workbook::Book.read("test string here", :ods) }
+    assert_raises(ArgumentError) { Workbook::Book.read("test string here", :xlsx) }
+  end
 end

data/test/test_format.rb

@@ -57,4 +57,43 @@ class TestFormat < Test::Unit::TestCase
     
   end
   
+  def test_parent_style
+    a = Workbook::Format.new({:background_color=>'#ffffff'})
+    b = Workbook::Format.new({:color=>'#000'})
+    a.parent = b
+    assert_equal(b, a.parent)
+  end
+  def test_parent_style_flattened_properties
+    a = Workbook::Format.new({:background_color=>'#ffffff'})
+    b = Workbook::Format.new({:color=>'#000'})
+    a.parent = b
+    assert_equal(Workbook::Format.new({:color=>'#000',:background_color=>'#ffffff'}), a.flattened)
+    c = Workbook::Format.new({:color=>'#f00'})
+    c.parent = a
+    assert_equal(Workbook::Format.new({:color=>'#f00',:background_color=>'#ffffff'}), c.flattened)
+  end
+  def test_formats
+    a = Workbook::Format.new({:background_color=>'#ffffff'})
+    b = Workbook::Format.new({:color=>'#000'})
+    c = Workbook::Format.new({:color=>'#f00'})
+    a.parent = b
+    c.parent = a
+    assert_equal([b,a,c], c.formats) 
+  end
+  def test_parent_style_to_css
+    a = Workbook::Format.new({:background_color=>'#ffffff'})
+    b = Workbook::Format.new({:color=>'#000'})
+    c = Workbook::Format.new({:color=>'#f00'})
+    a.parent = b
+    c.parent = a
+    assert_equal("background: #ffffff; color: #f00", c.to_css)
+  end
+  def test_all_names
+    a = Workbook::Format.new({:background_color=>'#ffffff'}, "a")
+    b = Workbook::Format.new({:color=>'#000'},"b")
+    c = Workbook::Format.new({:color=>'#f00'},"c")
+    a.parent = b
+    c.parent = a
+    assert_equal(["b","a","c"],c.all_names)
+  end
 end

data/test/test_modules_type_parser.rb

@@ -10,6 +10,8 @@ module Modules
        "2011-05-19T15_37_49 - 52349.xml"=>"2011-05-19T15_37_49 - 52349.xml",
        "20-2-2012 20:52"=>DateTime.new(2012,2,20,20,52),
        "1-11-2011"=>Date.new(2011,11,1),
+       "12/12/2012"=>Date.new(2012,12,12),
+       "12/23/1980"=>Date.new(1980,12,23), #TODO: should probably depend on locale, see: http://bugs.ruby-lang.org/issues/634#note-10
        "jA"=>"jA",
        "n"=>"n",
        "12 bomen"=>"12 bomen",

data/test/test_readers_csv_reader.rb

@@ -51,5 +51,49 @@ module Readers
       assert_equal(42000,w.sheet.table[3][:b].value)
       assert_equal(nil,w.sheet.table[2][:c].value)
     end
+    def test_class_read_string
+      s = File.read 'test/artifacts/simple_csv.csv'
+      w = Workbook::Book.read( s, :csv )
+      # reads
+      #       a,b,c,d
+      #       1,2,3,4
+      #       5,3,2,1
+      #       "asdf",123,12,2001-02-02
+      #       
+      assert_equal([:a,:b,:c,:d],w.sheet.table.header.to_symbols)
+      assert_equal(3,w.sheet.table[2][:b].value)
+      assert_equal("asdf",w.sheet.table[3][:a].value)
+      assert_equal(Date.new(2001,2,2),w.sheet.table[3][:d].value)
+    end
+    def test_instance_read_string
+      w = Workbook::Book.new
+      s = File.read 'test/artifacts/simple_csv.csv'
+      w.read( s, :csv )
+      # reads
+      #       a,b,c,d
+      #       1,2,3,4
+      #       5,3,2,1
+      #       "asdf",123,12,2001-02-02
+      #       
+      assert_equal([:a,:b,:c,:d],w.sheet.table.header.to_symbols)
+      assert_equal(3,w.sheet.table[2][:b].value)
+      assert_equal("asdf",w.sheet.table[3][:a].value)
+      assert_equal(Date.new(2001,2,2),w.sheet.table[3][:d].value)
+    end
+    def test_instance_read_stringio
+      w = Workbook::Book.new
+      sio = StringIO.new(File.read 'test/artifacts/simple_csv.csv')
+      w.read( sio, :csv )
+      # reads
+      #       a,b,c,d
+      #       1,2,3,4
+      #       5,3,2,1
+      #       "asdf",123,12,2001-02-02
+      #       
+      assert_equal([:a,:b,:c,:d],w.sheet.table.header.to_symbols)
+      assert_equal(3,w.sheet.table[2][:b].value)
+      assert_equal("asdf",w.sheet.table[3][:a].value)
+      assert_equal(Date.new(2001,2,2),w.sheet.table[3][:d].value)
+    end
   end
 end

data/test/test_readers_ods_reader.rb

@@ -0,0 +1,51 @@
+# -*- encoding : utf-8 -*-
+require File.join(File.dirname(__FILE__), 'helper')
+module Readers
+  class TestXlsWriter < Test::Unit::TestCase
+    def test_open
+      
+      w = Workbook::Book.new
+      w.open 'test/artifacts/book_with_tabs_and_colours.ods'
+      assert_equal([:a, :b, :c, :d, :e],w.sheet.table.header.to_symbols[0..4])
+      assert_equal(90588,w.sheet.table[2][:b].value)
+    end
+
+    def test_styling
+      w = Workbook::Book.new
+      w.open 'test/artifacts/book_with_tabs_and_colours.ods'
+      assert_equal("#ffff99",w.sheet.table[3][:c].format[:background_color])
+      assert_equal(true,w.sheet.table[0][:e].format.all_names.include?("Heading1"))
+      # TODO: column styles
+      # assert_equal(8.13671875,w.sheet.table.first[:b].format[:width])
+      # assert_equal(3.85546875,w.sheet.table.first[:a].format[:width])
+      # assert_equal(25.14453125,w.sheet.table.first[:c].format[:width])
+    end
+    
+    def test_complex_types
+      w = Workbook::Book.new
+      w.open 'test/artifacts/complex_types.ods'
+      assert_equal(Date.new(2011,11,15), w.sheet.table[2][3].value)
+      assert_equal("http://murb.nl", w.sheet.table[3][2].value)
+      assert_equal("sadfasdfsd", w.sheet.table[4][2].value)
+      assert_equal(1.2, w.sheet.table[3][1].value)
+    end
+    
+    def test_excel_standardized_open
+      w = Workbook::Book.new
+      w.open("test/artifacts/excel_different_types.ods")
+      # reads
+      #   a,b,c,d
+      # 2012-02-22,2014-12-27,2012-11-23,2012-11-12T04:20:00+00:00
+      # c,222.0,,0027-12-14T05:21:00+00:00
+      # 2012-01-22T11:00:00+00:00,42000.0,"goh, idd",ls
+      # 
+      assert_equal([:a,:b,:c, :d],w.sheet.table.header.to_symbols[0..3])
+      assert_equal(Date.new(2012,2,22),w.sheet.table[1][:a].value)
+      assert_equal("c",w.sheet.table[2][:a].value)
+      assert_equal(DateTime.new(2012,1,22,11),w.sheet.table[3][:a].value)
+      assert_equal(42000,w.sheet.table[3][:b].value)
+      assert_equal(nil,w.sheet.table[2][:c].value)
+    end
+    
+  end
+end

data/test/test_readers_txt_reader.rb

@@ -26,5 +26,58 @@ module Readers
       assert_equal(nil,w.sheet.table[2][:c].value)
     end
     
+    def test_excel_class_read_string
+      s = File.read("test/artifacts/excel_different_types.txt")
+      w = Workbook::Book.read(s, :txt)
+      # reads
+      #   a,b,c,d
+      # 2012-02-22,2014-12-27,2012-11-23,2012-11-12T04:20:00+00:00
+      # c,222.0,,0027-12-14T05:21:00+00:00
+      # 2012-01-22T11:00:00+00:00,42000.0,"goh, idd",ls
+      
+      assert_equal([:a,:b,:c, :d],w.sheet.table.header.to_symbols)
+      assert_equal(Date.new(2012,2,22),w.sheet.table[1][:a].value)
+      assert_equal("c",w.sheet.table[2][:a].value)
+      assert_equal(DateTime.new(2012,1,22,11),w.sheet.table[3][:a].value)
+      assert_equal(42000,w.sheet.table[3][:b].value)
+      assert_equal(nil,w.sheet.table[2][:c].value)
+    end
+    
+    def test_excel_instance_read_string
+      s = File.read("test/artifacts/excel_different_types.txt")
+      w = Workbook::Book.new
+      w.read(s, :txt)
+      # reads
+      #   a,b,c,d
+      # 2012-02-22,2014-12-27,2012-11-23,2012-11-12T04:20:00+00:00
+      # c,222.0,,0027-12-14T05:21:00+00:00
+      # 2012-01-22T11:00:00+00:00,42000.0,"goh, idd",ls
+      
+      assert_equal([:a,:b,:c, :d],w.sheet.table.header.to_symbols)
+      assert_equal(Date.new(2012,2,22),w.sheet.table[1][:a].value)
+      assert_equal("c",w.sheet.table[2][:a].value)
+      assert_equal(DateTime.new(2012,1,22,11),w.sheet.table[3][:a].value)
+      assert_equal(42000,w.sheet.table[3][:b].value)
+      assert_equal(nil,w.sheet.table[2][:c].value)
+    end
+    
+    def test_excel_instance_read_stringio
+      sio = StringIO.new(File.read("test/artifacts/excel_different_types.txt"))
+      w = Workbook::Book.new
+      w.read(sio, :txt)
+      # reads
+      #   a,b,c,d
+      # 2012-02-22,2014-12-27,2012-11-23,2012-11-12T04:20:00+00:00
+      # c,222.0,,0027-12-14T05:21:00+00:00
+      # 2012-01-22T11:00:00+00:00,42000.0,"goh, idd",ls
+      
+      assert_equal([:a,:b,:c, :d],w.sheet.table.header.to_symbols)
+      assert_equal(Date.new(2012,2,22),w.sheet.table[1][:a].value)
+      assert_equal("c",w.sheet.table[2][:a].value)
+      assert_equal(DateTime.new(2012,1,22,11),w.sheet.table[3][:a].value)
+      assert_equal(42000,w.sheet.table[3][:b].value)
+      assert_equal(nil,w.sheet.table[2][:c].value)
+    end
+    
   end
 end

data/test/test_row.rb

@@ -67,6 +67,18 @@ class TestRow < Test::Unit::TestCase
     assert_equal(r1, t.first) 
   end
   
+  def test_no_values?
+    t = Workbook::Table.new
+    r1 = Workbook::Row.new
+    r1.table = t
+    assert_equal(true, r1.no_values?)
+    r1 << Workbook::Cell.new('abcd')
+    assert_equal(false, r1.no_values?)
+    r2 = Workbook::Row.new [nil, '', nil, '', '']
+    r2.table = t
+    assert_equal(true, r2.no_values?)
+  end
+  
   def test_to_symbols
     r1 = Workbook::Row.new ["test", "asdf-asd", "asdf - asdf", "asdf2"]
     assert_equal([:test, :asdfasd, :asdf_asdf, :asdf2], r1.to_symbols)

data/test/test_sheet.rb

@@ -42,4 +42,16 @@ class TestWorkbook < Test::Unit::TestCase
     assert_equal(5,s2.table[2][:a])
   end
  
+  def test_create_or_open_table_at
+    s = Workbook::Sheet.new
+    table0=s.create_or_open_table_at(0)
+    assert_equal(Workbook::Table, table0.class)
+    assert_equal(s, table0.sheet)
+    table1=s.create_or_open_table_at(1)
+    assert_equal(Workbook::Table, table1.class)
+    assert_equal(s, table1.sheet)
+    table1<<Workbook::Row.new([1,2,3,4])    
+    assert_equal(false, table1 == table0)    
+    
+  end
 end