rexcel 0.1.1 → 0.1.2

data/lib/rexcel/worksheet.rb

@@ -1,28 +1,29 @@
+#encoding: utf-8
 module Excel
 =begin rdoc
 Implements a worksheet.
 
 Worksheets are part of a Workbook and contain Row
 =end
-class Worksheet
-  def initialize( name = nil, options = {})
-    @log = options[:log] || LOGGER
-    @name = name || 'Sheet'
-    #Array with columns sequence. Needed to insert Hashes.
-    @columns = {}
-    @rows = []
-    options.each{|key,value|
-      case key
-        when :log
-        else
-          @log.warn("Excel::Worksheet: undefined option #{option}")
-      end
-    }
-  end
-  #Name of the sheet
-  attr_reader :name
-  #Array with rows
-  attr_reader :rows
+  class Worksheet
+    def initialize( name = nil, options = {})
+      @log = options[:log] || LOGGER
+      @name = name || 'Sheet'
+      #Array with columns sequence. Needed to insert Hashes.
+      @columns = {}
+      @rows = []
+      options.each{|key,value|
+        case key
+          when :log
+          else
+            @log.warn("Excel::Worksheet: undefined option #{option}")
+        end
+      }
+    end
+    #Name of the sheet
+    attr_reader :name
+    #Array with rows
+    attr_reader :rows
 =begin rdoc
 Add content to the worksheet.
 * Array: Added as Row to the actual worksheet.
@@ -31,80 +32,123 @@ Add content to the worksheet.
 
 If no actual worksheet is available, a new worksheet i created.
 =end
-  def << (insertion)
-    case insertion
-      when Column
-        @columns[insertion.id] = insertion
-      when Array
-        @rows << row = Row.new()
-        row << insertion
-      when Hash
-        raise ArgumentError, "#{Worksheet}: Hash without heading data" if @columns.empty?
-        @rows << row = Row.new()
-        #Hashes keep the order of entry. -> no internal order necessary
-        @columns.each{|id, column|
-          row << insertion[id]
-        }
-      when Row
-        @rows << insertion
-      else
-        raise ArgumentError, "#{Worksheet}: Wrong insertion type #{insertion.inspect}"
+    def << (insertion)
+      case insertion
+        when Column
+          @columns[insertion.id] = insertion
+        when Array
+          @rows << row = Row.new()
+          row << insertion
+        when Hash
+          raise ArgumentError, "#{Worksheet}: Hash without heading data" if @columns.empty?
+          @rows << row = Row.new()
+          #Hashes keep the order of entry. -> no internal order necessary
+          @columns.each{|id, column|
+            row << insertion[id]
+          }
+        when Row
+          @rows << insertion
+        else
+          raise ArgumentError, "#{Worksheet}: Wrong insertion type #{insertion.inspect}"
+      end
     end
-  end
 =begin rdoc
 Add a title line from columns data.
 
 
 =end
-def add_title_row(columns = @columns, style = Style.new("Title_row#{object_id}", :bold => true))
-  #~ raise ArgumentError, "#{Worksheet}##{__method__}: No columns list found" unless columns.respond_to?(:each)
-  raise ArgumentError, "#{Worksheet}##{__method__}: No columns list found" unless columns.is_a?(Hash)
-  raise ArgumentError, "#{Worksheet}##{__method__}: Columns list empty" if columns.empty?
-  
-  @rows << row = Row.new(:style => style )
-  #Hashes keep the order of entry. -> no internal order necessary
-  columns.each{|id, column|
-    row << Cell.new(column.title)
-  }
-  row
-end
+    def add_title_row(columns = @columns, style = Style.new("Title_row#{object_id}", :bold => true))
+      #~ raise ArgumentError, "#{Worksheet}##{__method__}: No columns list found" unless columns.respond_to?(:each)
+      raise ArgumentError, "#{Worksheet}##{__method__}: No columns list found" unless columns.is_a?(Hash)
+      raise ArgumentError, "#{Worksheet}##{__method__}: Columns list empty" if columns.empty?
+      
+      @rows << row = Row.new(:style => style )
+      #Hashes keep the order of entry. -> no internal order necessary
+      columns.each{|id, column|
+        row << Cell.new(column.title)
+      }
+      row
+    end
 =begin rdoc
 Build the xml for the work sheet.
 
 ns must be a method-object to implement the namespace definitions.
 =end
-  def to_xml(xmlbuilder, ns)
-    raise EmptyError, "Worksheet #{@name} without content" if @rows.empty?
+    def to_xml(xmlbuilder, ns)
+      raise EmptyError, "Worksheet #{@name} without content" if @rows.empty?
 
-    @log.debug("Prepare XML for worksheet #{@name}")
-    xmlbuilder[ns.call].Worksheet(ns.call('Name') => @name){
-      xmlbuilder[ns.call].Table(){
-        @columns.each{|id,column| column.to_xml(xmlbuilder, ns) }
-        @rows.each{|row|
-          row.to_xml(xmlbuilder, ns)
-        } #row
+      @log.debug("Prepare XML for worksheet #{@name}")
+      xmlbuilder[ns.call].Worksheet(ns.call('Name') => @name){
+        xmlbuilder[ns.call].Table(){
+          @columns.each{|id,column| column.to_xml(xmlbuilder, ns) }
+          @rows.each{|row|
+            row.to_xml(xmlbuilder, ns)
+          } #row
+        }
       }
-    }
-  end #to_xml
+    end #to_xml
 =begin rdoc
 Build the xls for the work sheet.
 
 Receives a OLE-Worksheet.
 =end
-  def to_xls(ws)
-    @log.debug("Prepare Worksheet #{@name}")
-    ws.Name = @name
-    
-    #fixme: Add styles
-    #~ @log.warn("XLS contains no styles")
+    def to_xls(ws)
+      @log.debug("Prepare Worksheet #{@name}")
+      ws.Name = @name
+      
+      #fixme: Add styles
+      #~ @log.warn("XLS contains no styles")
+      
+      @rows.each_with_index{|row, rownum|
+        row.columns.each_with_index{|col, colnum|
+          @log.debug("Prepare cell #{rownum+1},#{colnum+1}")
+          col.to_xls( ws.Cells(rownum+1, colnum+1), row )
+        }#columns in row
+      }#rows
+    end #to_xls
+=begin rdoc
+Build a csv for the work sheet.
+
+The csv is optimized to be used by Excel.
+The field content are converted for this target.
+
+Probably the csv expects a German Excel.
+Details see Rexcel::Cell#to_csv.
+
+
+Options:
+* :sep cell separator. default: ; (as expected from Excel)
+* :filename: Store the data to a file (optional).
+* :encoding: Used for storage in filename. Default: UTF-16LE
+
+fixme::
+* :filehandle
+=end
+    def to_csv( options = {} )
+      @log.debug("Prepare Worksheet #{@name} for csv-output")
+      (options.keys - [:sep, :filename, :encoding] ).each{|option|
+        @log.warn("Undefined option #{option} in #{self.class}##{__method__}")
+      }
+      #Set options defaults
+      options[:encoding] ||= "UTF-16LE"
+      #~ options[:filename] ||= 'test.csv'  #no default 
     
-    @rows.each_with_index{|row, rownum|
-    row.columns.each_with_index{|col, colnum|
-      @log.debug("Prepare cell #{rownum+1},#{colnum+1}")
-      col.to_xls( ws.Cells(rownum+1, colnum+1), row )
-      }#columns in row
-    }#rows
-  end #to_xls
-  
-end #class Worksheet
+      csv = []
+      
+      @rows.each_with_index{|row, rownum|        
+        @log.debug("Prepare row #{rownum} for csv-output") if @log.debug?
+        csv << row.to_csv(options)
+      }#rows
+      
+      #Save to file if requested
+      if options[:filename]
+        File.open(options[:filename], 'w', :encoding => options[:encoding] ){|csv_file|
+          csv_file << csv.join("\n")
+        }
+      end #if options[:filename]
+      
+      csv.join("\n")
+    end #to_csv
+        
+  end #class Worksheet
 end #module Excel

data/readme.rdoc

@@ -0,0 +1,66 @@
+:title:Create Excel-documents with ruby
+Build Excel documents via win32ole.
+
+
+This gem was tested with
+* Windows XP + MS Excel 2007 (Version 12)
+* Windows 7  + MS Excel 2007 (Version 12)
+
+==Example 1 (Simple Spreadsheet):
+  require 'excel'
+  
+  wb = Excel::Workbook.new()
+
+  wb << [1,2,3,4,5,6,7]
+  wb << [:a, :b, :c, :d, :e, :f]
+
+  #Save as excel spreadsheets
+  wb.save('test.xls') #excel97_2003_format
+  wb.save('test.xlsx')  #Excel 2007
+  
+  wb.save('test.xml') #Microsoft Office Word 2003 XML Format
+  wb.save('test.xls', 'test.xml')#Build xls from xlm
+
+==Example 2 (Access to Worksheets, Rows and Cells):
+  require 'excel'
+  
+  wb = Excel::Workbook.new()
+
+  wb << ws = Excel::Worksheet.new('My Spreadsheet')
+  ws << row = Excel::Row.new()
+  row << Excel::Cell.new(1)
+  row << Excel::Cell.new(2)
+  row << Excel::Cell.new(4)
+
+  #Save as excel spreadsheets
+  wb.save('test.xls') #excel97_2003_format
+  wb.save('test.xlsx')  #Excel 2007
+  
+  wb.save('test.xml') #Microsoft Office Word 2003 XML Format
+  wb.save('test.xls', 'test.xml')#Build xls from xlm
+
+==Example 3 (With Format options):
+  require 'excel'
+  
+  wb = Excel::Workbook.new()
+  wb << style = Excel::Style.new('fett', :bold => true)
+
+  wb << ws = Excel::Worksheet.new('My Spreadsheet')
+  ws << row = Excel::Row.new()
+  row << Excel::Cell.new(1)
+  row << Excel::Cell.new(2)
+  row << Excel::Cell.new(999, :style => style)
+
+  #Save as excel spreadsheets
+  wb.save('test.xls') #excel97_2003_format
+  wb.save('test.xlsx')  #Excel 2007
+  
+  wb.save('test.xml') #Microsoft Office Word 2003 XML Format
+  wb.save('test.xls', 'test.xml')#Build xls from xlm
+
+
+'Big' spreadsheets needs a long time to be build.
+(20000 lines need 2 hours)
+
+When you build the xml, and then the xls from xlm, the wor is done in seconds.
+

data/unittest/expected/Test_Workbook_to_csv-test_filename.csv

@@ -0,0 +1,4 @@
+a;b;c;d
+a;b;c;d
+1;2;3;4
+="1.1";="2.2";="3.3";="4.4"

data/unittest/expected/Test_Workbook_to_csv-test_filename_encoding.csv

@@ -0,0 +1,4 @@
+a;b;c;d
+a;b;c;d
+1;2;3;4
+="1.1";="2.2";="3.3";="4.4"

data/unittest/expected/Test_Worksheet_to_csv-test_filename.csv

@@ -0,0 +1,4 @@
+a;b;c;d
+a;b;c;d
+1;2;3;4
+="1.1";="2.2";="3.3";="4.4"

data/unittest/expected/Test_Worksheet_to_csv-test_filename_encoding.csv

@@ -0,0 +1,4 @@
+a;b;c;d
+a;b;c;d
+1;2;3;4
+="1.1";="2.2";="3.3";="4.4"

data/unittest/rexcel_test_helper.rb

@@ -0,0 +1,91 @@
+#~ gem 'test-unit', ">= 2.1.2"  #tested with this version
+gem 'test-unit', ">= 2.1"
+require 'test/unit'
+require "more_unit_test/assert_equal_filecontent.rb" #assert_equal_filecontent
+
+$:.unshift('../lib') #if $0 == __FILE__
+require 'rexcel'
+Excel::LOGGER.level = Log4r::OFF #only really important messages
+
+#Encoding from OLE/Excel
+XLS_ENCODING = Encoding.find("CP850")
+
+
+=begin rdoc
+Mock a document.
+
+Must defined
+* namespace, including the ns-method
+* xml-frame using and defining the namespace
+
+Usage:
+    assert_equal(%{},
+      @mock.testcase{|builder, ns_proc|
+        row.to_xml( builder,ns_proc)
+    })   
+=end
+class Mock_document
+  def  initialize()
+    @namespace = 'ss'
+  end
+  def ns(attr=nil)
+        attr ?  "%s:%s" % [@namespace, attr] : @namespace
+  end
+=begin rdoc
+Build relevant xml-part
+=end
+  def testcase()
+    builder = Nokogiri::XML::Builder.new(){|builder|
+      builder.Test( "xmlns:#{@namespace}"  =>"urn:schemas-microsoft-com:office:spreadsheet"){|builder|
+        yield builder, method(:ns)
+        }
+      }
+      
+      # builder.to_xml #complete xml
+      
+      #extract content from block
+      doc = Nokogiri::XML::Document.parse(builder.to_xml)
+      doc.at_css('Test').children.to_xml.strip
+  end
+end
+
+
+=begin rdoc
+Check identic content of xls[x]-files with Beyond Compare
+and returns the returncode
+
+RCs:
+  0 Success
+  1 Binary same
+  2 Rules-based same
+  11 Binary differences
+  12 Similar
+  13 Rules-based differences
+  14 Conflicts detected
+  100 Unknown error
+  101 Conflicts detected, merge output not written
+  102 BComp.exe unable to wait until BCompare.exe finishes
+  103 BComp.exe cannot find BCompare.exe
+  104 Trial period expired
+  105 Error loading script file
+  106 Script syntax error
+  107 Script failed to load folders or files
+ 
+Doesn't recognize type differences (eg. 1 == '1' )
+=end
+def compare_with_bc3(file1,file2)
+  
+  bc_exe = "C:\\Program Files\\Beyond Compare 3\\BCompare.exe"
+  if ! File.exist?(bc_exe)
+    omit "Beyond compare not found - ignore test"
+    #Alternative: return 2  #report ok
+  end
+  cmd = [
+    '"%s"' % bc_exe,
+    file1, file2,
+    '/qc'
+    ].join(" ")
+    
+    system(cmd)
+    $? >> 8 #exit status
+end

data/unittest/test_rexcel.rb

@@ -1,6 +1,5 @@
 #encoding: UTF-8
-require 'test/unit'
-require "more_unit_test/assert_equal_filecontent.rb" #assert_equal_filecontent
+require_relative 'rexcel_test_helper'
 
 =begin
 Offen:
@@ -8,93 +7,11 @@ Offen:
 * Attribute (row/cell)
 =end
 
-$:.unshift('../lib') if $0 == __FILE__
-require 'rexcel'
-Excel::LOGGER.level = Log4r::OFF #only really important messages
-
-#Encoding from OLE/Excel
-XLS_ENCODING = Encoding.find("CP850")
-
-=begin rdoc
-Mock a document.
-
-Must defined
-* namespace, including the ns-method
-* xml-frame using and defining the namespace
-
-Usage:
-    assert_equal(%{},
-      @mock.testcase{|builder, ns_proc|
-        row.to_xml( builder,ns_proc)
-    })   
-=end
-class Mock_document
-  def  initialize()
-    @namespace = 'ss'
-  end
-  def ns(attr=nil)
-        attr ?  "%s:%s" % [@namespace, attr] : @namespace
-  end
-=begin rdoc
-Build relevant xml-part
-=end
-  def testcase()
-    builder = Nokogiri::XML::Builder.new(){|builder|
-      builder.Test( "xmlns:#{@namespace}"  =>"urn:schemas-microsoft-com:office:spreadsheet"){|builder|
-        yield builder, method(:ns)
-        }
-      }
-      
-      # builder.to_xml #complete xml
-      
-      #extract content from block
-      doc = Nokogiri::XML::Document.parse(builder.to_xml)
-      doc.at_css('Test').children.to_xml.strip
-  end
-end
-=begin rdoc
-CHeck identic content of xls[x]-files with Beyond Compare.
-
-RCs:
-  0 Success
-  1 Binary same
-  2 Rules-based same
-  11 Binary differences
-  12 Similar
-  13 Rules-based differences
-  14 Conflicts detected
-  100 Unknown error
-  101 Conflicts detected, merge output not written
-  102 BComp.exe unable to wait until BCompare.exe finishes
-  103 BComp.exe cannot find BCompare.exe
-  104 Trial period expired
-  105 Error loading script file
-  106 Script syntax error
-  107 Script failed to load folders or files
- 
-Doesn't recognice type differences (eg. 1 == '1' )
-=end
-
-def test_bc(file1,file2)
-  
-  bc_exe = "C:\\Program Files\\Beyond Compare 3\\BCompare.exe"
-  if ! File.exist?(bc_exe)
-    puts "Beyond compare not found - ignore test"
-    return 2
-  end
-  cmd = [
-    '"%s"' % bc_exe,
-    file1, file2,
-    '/qc'
-    ].join(" ")
-    
-    system(cmd)
-    $? >> 8 #exit status
-end
 
 class Test_excel < Test::Unit::TestCase  
   def test_version()
-    assert_equal('0.1.1', Excel::VERSION)
+    assert_equal('0.1.2', Excel::VERSION)
+    #~ pend "Check version"
   end
 end #class Test_excel < Test::Unit::TestCase
   
@@ -109,211 +26,21 @@ class Test_ole < Test::Unit::TestCase
     #~ Excel::Excel.instance.reconnect
     #~ assert_instance_of( WIN32OLE, Excel::Excel.instance.xl )
   end
-
-
-end #class Test_excel < Test::Unit::TestCase
-
-
-class Test_workbook < Test::Unit::TestCase
-  FILELIST = %w{
-    test_save_xml.xml test_save_xml.xls test_save_xml.xlsx 
-    test_save.xls test_save.xlsx}
-  def setup()
-    FILELIST.each{|fn|
-      File.delete(fn) if File.exist?(fn)
-    }
-  end
-  def teardown()
-    FILELIST.each{|fn|
-      File.delete(fn) if File.exist?(fn)
-    }
-  end
-  def test_init()
-    assert_nothing_raised{ Excel::Workbook.new() }
-    assert_nothing_raised{ Excel::Workbook.new( Excel::LOGGER) }
-    assert_raise(ArgumentError){ Excel::Workbook.new( 1 ) }
-  end
   
-  def test_save_xml()
-    
-    assert_false( File.exist?('test_save_xml.xml'))
-    assert_false( File.exist?('test_save_xml.xls'))
-    assert_false( File.exist?('test_save_xml.xlsx'))
-
-    wb = Excel::Workbook.new()
-    wb << [1,2,3] #add anything, else you get an error
-    wb << ['a','b','c'] #add anything, else you get an error
-    assert_nothing_raised{ wb.save('test_save_xml.xml') }
-    assert_nothing_raised{ wb.save('test_save_xml.xls', 'test_save_xml.xml')}
-    assert_nothing_raised{ wb.save('test_save_xml.xlsx', 'test_save_xml.xml')}
-
-    assert_true( File.exist?('test_save_xml.xml'))
-    assert_true( File.exist?('test_save_xml.xls'))
-    assert_true( File.exist?('test_save_xml.xlsx'))
-
-
-    #~ assert_equal_filecontent( "expected/%s-%s.xml" %[self.class, __method__], 
-                                        #~ wb.build_excel_xml('ss') )
-    assert_equal( %{<?xml version="1.0"?>
-<ss:Workbook xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
-    <ss:Worksheet ss:Name="Sheet0">
-        <ss:Table>
-            <ss:Row>
-                <ss:Cell>
-                    <ss:Data ss:Type="Number">1</ss:Data>
-                </ss:Cell>
-                <ss:Cell>
-                    <ss:Data ss:Type="Number">2</ss:Data>
-                </ss:Cell>
-                <ss:Cell>
-                    <ss:Data ss:Type="Number">3</ss:Data>
-                </ss:Cell>
-            </ss:Row>
-            <ss:Row>
-                <ss:Cell>
-                    <ss:Data ss:Type="String">a</ss:Data>
-                </ss:Cell>
-                <ss:Cell>
-                    <ss:Data ss:Type="String">b</ss:Data>
-                </ss:Cell>
-                <ss:Cell>
-                    <ss:Data ss:Type="String">c</ss:Data>
-                </ss:Cell>
-            </ss:Row>
-        </ss:Table>
-    </ss:Worksheet>
-</ss:Workbook>}, 
-                                        wb.build_excel_xml('ss') )
-    
-    assert_equal( 2, test_bc('test_save_xml.xls', 'test_save_xml.xlsx'))
-
+  def test_system()
+    #sinnvoll??
+    assert_equal( 'Microsoft Excel', Excel::Excel.instance.xl.Name)
+    #Both ok.
+    #~ assert_equal( 'Windows (32-bit) NT 5.01', Excel::Excel.instance.xl.OperatingSystem )
+    #~ assert_equal( 'Windows (32-bit) NT 6.01', Excel::Excel.instance.xl.OperatingSystem )
+    #~ assert_equal( '12', Excel::Excel.instance.xl.version )  #Build number 12 (Office 2007)
+    #~ assert_equal( '12.0', Excel::Excel.instance.xl.version )  #Build number 12 (Office 2007)
   end
-  
-  def test_save_xls()
-    
-    assert_false( File.exist?('test_save.xls'))
-    assert_false( File.exist?('test_save.xlsx'))
 
-    wb = Excel::Workbook.new()
-    wb << [ 1,2,3,4]
-    wb << [ :a, :b, :c ]
-    assert_nothing_raised{ wb.save('test_save.xls')}
-    assert_nothing_raised{ wb.save('test_save.xlsx')}
-    
-    assert_true( File.exist?('test_save.xls'))
-    assert_true( File.exist?('test_save.xlsx'))
-
-    assert_equal( 2, test_bc('test_save.xls', 'test_save.xlsx'))
-
-    assert_false( File.exist?('test_save.xml'))
-    assert_false( File.exist?('test_save_xml.xls'))
-    assert_nothing_raised{ wb.save('test_save_xml.xml')}
-    assert_nothing_raised{ wb.save('test_save_xml.xlsx', 'test_save_xml.xml')}
-    assert_true( File.exist?('test_save_xml.xml'))
-    assert_true( File.exist?('test_save_xml.xlsx'))
-    assert_equal( 2, test_bc('test_save.xlsx', 'test_save_xml.xlsx'))
-
-  end #def test_create_wb()
-
-  def test_save_other()
-    wb = Excel::Workbook.new()
-    assert_raise( ArgumentError ){wb.save('test_save_xml.doc')}
-  end
-end #class Test_workbook 
 
-class Test_workbook_insertions < Test::Unit::TestCase
-  def test_insert_worksheet()
-    wb = Excel::Workbook.new()
-    assert_equal(0, wb.worksheets.size)
-    
-    assert_nothing_raised{ wb << Excel::Worksheet.new()  }    
-    assert_equal(1, wb.worksheets.size)
-    assert_equal('Sheet', wb.worksheets.last.name)
-    
-    assert_nothing_raised{ wb << Excel::Worksheet.new('Sheet for test')  }
-    assert_equal(2, wb.worksheets.size)
-    assert_equal('Sheet for test', wb.worksheets.last.name)
-  end
-  def test_insert_array
-    wb = Excel::Workbook.new()
-    assert_equal(0, wb.worksheets.size)
-    assert_nothing_raised{ wb <<  [:a,:b,:c,:d] }
-    assert_equal(1, wb.worksheets.size)
-    assert_equal(%{<?xml version="1.0"?>
-<ss:Workbook xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
-    <ss:Worksheet ss:Name="Sheet0">
-        <ss:Table>
-            <ss:Row>
-                <ss:Cell>
-                    <ss:Data ss:Type="String">a</ss:Data>
-                </ss:Cell>
-                <ss:Cell>
-                    <ss:Data ss:Type="String">b</ss:Data>
-                </ss:Cell>
-                <ss:Cell>
-                    <ss:Data ss:Type="String">c</ss:Data>
-                </ss:Cell>
-                <ss:Cell>
-                    <ss:Data ss:Type="String">d</ss:Data>
-                </ss:Cell>
-            </ss:Row>
-        </ss:Table>
-    </ss:Worksheet>
-</ss:Workbook>},
-        wb.build_excel_xml( 'ss' )
-    )       
-    assert_nothing_raised{ wb <<  [:a,:b,:c,:d] }
-  end
-  def test_insert_row()
-    wb = Excel::Workbook.new()
-    assert_equal(0, wb.worksheets.size)
-    assert_nothing_raised{ wb <<  Excel::Row.new() }
-    assert_equal(1, wb.worksheets.size)
-    #Exception for empty row
-    assert_raise( Excel::EmptyError ){ wb.build_excel_xml( 'ns' ) }
-  end  
-  def test_insert_hash()
-    wb = Excel::Workbook.new()
-    assert_equal(0, wb.worksheets.size)
-    assert_equal(nil, wb.active_worksheet)
-    #Hash requires Heading data
-    assert_raise( ArgumentError ){ wb <<  { 1 => :a, 2 => :b, 3 => :c } }
-    assert_equal(1, wb.worksheets.size)
-    assert_instance_of(Excel::Worksheet, wb.active_worksheet)
-    
-    ws = wb.active_worksheet
-    ws << Excel::Column.new( 1 )
-    ws << Excel::Column.new( 2 )
-    
-    assert_nothing_raised{ wb <<  { 1 => :a, 2 => :b, 3 => :c } }
-    assert_equal(1, wb.worksheets.size)#no new worksheet created
-    assert_equal(%{<?xml version="1.0"?>
-<ss:Workbook xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
-    <ss:Worksheet ss:Name="Sheet0">
-        <ss:Table>
-            <ss:Column/>
-            <ss:Column/>
-            <ss:Row>
-                <ss:Cell>
-                    <ss:Data ss:Type="String">a</ss:Data>
-                </ss:Cell>
-                <ss:Cell>
-                    <ss:Data ss:Type="String">b</ss:Data>
-                </ss:Cell>
-            </ss:Row>
-        </ss:Table>
-    </ss:Worksheet>
-</ss:Workbook>},
-        wb.build_excel_xml( 'ss' )
-    )       
+end #class Test_excel < Test::Unit::TestCase
 
-  end #def test_insert()
-  def test_insert_other()
-    wb = Excel::Workbook.new()
-    assert_raise(ArgumentError){ wb << 1 }
-  end
 
-end #class Test_workbook
 
 class Test_Columns < Test::Unit::TestCase
   def test_init
@@ -361,303 +88,6 @@ class Test_Columns_xml < Test::Unit::TestCase
   
 end #class Test_Columns_xml < Test::Unit::TestCase
   
-class Test_Worksheet < Test::Unit::TestCase
-  def test_init
-    ws = Excel::Worksheet.new()
-    assert_equal('Sheet', ws.name)
-    assert_equal([], ws.rows)
-    #~ assert_equal({}, ws.columns) #only internal.
-  end #def test_init
-  def test_add_title_row
-    ws = Excel::Worksheet.new()
-    assert_raise(ArgumentError){ ws.add_title_row(:xx) } #no #each
-    assert_raise(ArgumentError){ ws.add_title_row([]) } #wrong type
-    assert_raise(ArgumentError){ ws.add_title_row({}) } #empty
-
-    assert_raise(ArgumentError){ ws.add_title_row() }#no columns defined
-    
-    title_row = ws.add_title_row({ 1 => Excel::Column.new(1), 2=> Excel::Column.new(2)})
-    assert_instance_of(Excel::Row, title_row)
-    assert_equal(2, title_row.columns.size)
-
-  end
-end #class Test_Worksheet 
-class Test_Worksheet_insertions < Test::Unit::TestCase
-  def setup()
-    @mock = Mock_document.new
-  end  
-  def test_insert_array
-    ws = Excel::Worksheet.new()
-    assert_equal(0, ws.rows.size)
-    assert_raise(Excel::EmptyError){
-      @mock.testcase{|builder, ns_proc|
-        ws.to_xml( builder,ns_proc)
-    }}
-    assert_nothing_raised{ ws <<  [:a,:b,:c,:d] }
-    assert_equal(1, ws.rows.size)
-    assert_equal(%{<ss:Worksheet ss:Name="Sheet">
-    <ss:Table>
-      <ss:Row>
-        <ss:Cell>
-          <ss:Data ss:Type="String">a</ss:Data>
-        </ss:Cell>
-        <ss:Cell>
-          <ss:Data ss:Type="String">b</ss:Data>
-        </ss:Cell>
-        <ss:Cell>
-          <ss:Data ss:Type="String">c</ss:Data>
-        </ss:Cell>
-        <ss:Cell>
-          <ss:Data ss:Type="String">d</ss:Data>
-        </ss:Cell>
-      </ss:Row>
-    </ss:Table>
-  </ss:Worksheet>},
-      @mock.testcase{|builder, ns_proc|
-        ws.to_xml( builder,ns_proc)
-    })       
-    assert_nothing_raised{ ws <<  [:a,:b,:c,:d] }
-  end
-  def test_insert_row()
-    ws = Excel::Worksheet.new()
-    assert_equal(0, ws.rows.size)
-    assert_nothing_raised{ ws << ( Excel::Row.new()  << 'a') }
-    assert_equal(1, ws.rows.size)
-    assert_equal(%{<ss:Worksheet ss:Name="Sheet">
-    <ss:Table>
-      <ss:Row>
-        <ss:Cell>
-          <ss:Data ss:Type="String">a</ss:Data>
-        </ss:Cell>
-      </ss:Row>
-    </ss:Table>
-  </ss:Worksheet>},
-      @mock.testcase{|builder, ns_proc|
-        ws.to_xml( builder,ns_proc)
-    })       
-  end  
-  def test_insert_hash()
-    ws = Excel::Worksheet.new()
-    assert_equal(0, ws.rows.size)
-    #Hash requires Heading data
-    assert_raise( ArgumentError ){ ws <<  { 1 => :a, 2 => :b, 3 => :c } }
-    assert_equal(0, ws.rows.size)
-    
-    ws << Excel::Column.new(1)
-    ws << Excel::Column.new(2)
-    
-    assert_nothing_raised{ ws <<  { 1 => :a, 2 => :b, 3 => :c } }
-    assert_equal(1, ws.rows.size)
-    assert_equal(%{<ss:Worksheet ss:Name="Sheet">
-    <ss:Table>
-      <ss:Column/>
-      <ss:Column/>
-      <ss:Row>
-        <ss:Cell>
-          <ss:Data ss:Type="String">a</ss:Data>
-        </ss:Cell>
-        <ss:Cell>
-          <ss:Data ss:Type="String">b</ss:Data>
-        </ss:Cell>
-      </ss:Row>
-    </ss:Table>
-  </ss:Worksheet>},
-      @mock.testcase{|builder, ns_proc|
-        ws.to_xml( builder,ns_proc)
-    })       
-
-  end #def test_insert()
-  def test_insert_other()
-    ws = Excel::Worksheet.new()
-    assert_raise(ArgumentError){ ws << 1 }
-    assert_raise(ArgumentError){ ws << Excel::Worksheet.new()  }
-  end
-
-end #class Test_Worksheet
-
-class Test_Row < Test::Unit::TestCase
-  def test_style()
-    style = Excel::Style.new('style_example')
-    assert_equal( nil, Excel::Row.new.style)
-    assert_instance_of( Excel::Style, Excel::Row.new(:style => style).style)
-    assert_equal( style, Excel::Row.new(:style => style).style)
-  end
-end
-class Test_Row_insertions < Test::Unit::TestCase
-  def setup()
-    @mock = Mock_document.new
-  end
-  def test_insert_array
-    row = Excel::Row.new()
-    assert_equal(0, row.columns.size)
-    assert_nothing_raised{ row <<  [:a,:b,:c,:d] }
-    assert_equal(%{<ss:Row>
-    <ss:Cell>
-      <ss:Data ss:Type="String">a</ss:Data>
-    </ss:Cell>
-    <ss:Cell>
-      <ss:Data ss:Type="String">b</ss:Data>
-    </ss:Cell>
-    <ss:Cell>
-      <ss:Data ss:Type="String">c</ss:Data>
-    </ss:Cell>
-    <ss:Cell>
-      <ss:Data ss:Type="String">d</ss:Data>
-    </ss:Cell>
-  </ss:Row>},
-      @mock.testcase{|builder, ns_proc|
-        row.to_xml( builder,ns_proc)
-    })
-    assert_equal(4, row.columns.size)
-    assert_nothing_raised{ row <<  [:a,:b,:c,:d] }
-  end
-  def test_insert_hash()
-    row = Excel::Row.new()
-    assert_equal(0, row.columns.size)
-    #Hash requires Heading data
-    assert_raise( ArgumentError ){ row <<  { 1 => 1, 2 => 2, 3 => 3 } }
-    assert_equal(0, row.columns.size)
-  end #def test_insert()
-  def test_insert_other()
-    row = Excel::Row.new()
-    assert_equal(0, row.columns.size)
-    assert_raise(Excel::EmptyError){
-      @mock.testcase{|builder, ns_proc|row.to_xml( builder,ns_proc)}
-    }
-    assert_nothing_raised{ row << 'a' }
-    assert_equal(1, row.columns.size)
-    assert_equal(%{<ss:Row>
-    <ss:Cell>
-      <ss:Data ss:Type="String">a</ss:Data>
-    </ss:Cell>
-  </ss:Row>},
-      @mock.testcase{|builder, ns_proc|
-        row.to_xml( builder,ns_proc)
-    })    
-    assert_nothing_raised{ row << 'x' }
-    assert_equal(2, row.columns.size)
-    assert_equal(%{<ss:Row>
-    <ss:Cell>
-      <ss:Data ss:Type="String">a</ss:Data>
-    </ss:Cell>
-    <ss:Cell>
-      <ss:Data ss:Type="String">x</ss:Data>
-    </ss:Cell>
-  </ss:Row>},
-      @mock.testcase{|builder, ns_proc|
-        row.to_xml( builder,ns_proc)
-    })
-  end
-  def test_insert_errors()  
-    row = Excel::Row.new()
-    assert_raise(ArgumentError){ row << Excel::Row.new()  }
-    assert_raise(ArgumentError){ row << Excel::Worksheet.new()  }
-    assert_raise(ArgumentError){ row << Excel::Workbook.new()  }
-  end
-  
-  #~ def test_bold()
-    #~ pend("#{self.class}##{__method__} output")
-  #~ end
-  #~ def test_italic()
-    #~ pend("#{self.class}##{__method__} output")
-  #~ end
-  #~ def test_color()
-    #~ pend("#{self.class}##{__method__} output")
-  #~ end
-  #~ def test_backgroundcolor()
-    #~ pend("#{self.class}##{__method__} output")
-  #~ end
-
-end #class Test_Row
-
-
-class Test_Cell < Test::Unit::TestCase
-  def test_create()
-    assert_nil( Excel::Cell.new().content)
-    assert_equal( 1, Excel::Cell.new(1).content)
-  end #def test_create()
-  def test_style()
-    style = Excel::Style.new('style_example')
-    assert_equal( nil, Excel::Cell.new(1).style)
-    assert_instance_of( Excel::Style, Excel::Cell.new(1, :style => style).style)
-    assert_equal( style, Excel::Cell.new(1, :style => style).style)
-  end
-  
-end #class Test_Cell
-
-class Test_Cell_xml < Test::Unit::TestCase
-  def setup()
-    @mock = Mock_document.new
-  end
-  def test_content_string
-    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"String\">content</ss:Data>\n  </ss:Cell>",
-      @mock.testcase{|builder, ns_proc|
-            cell = Excel::Cell.new('content')
-            cell.to_xml( builder,ns_proc)
-    })
-  end
-  def test_content_number
-    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"Number\">1</ss:Data>\n  </ss:Cell>",
-      @mock.testcase{|builder, ns_proc|
-            cell = Excel::Cell.new(1)
-            cell.to_xml( builder,ns_proc)
-    })
-    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"Number\">1.1</ss:Data>\n  </ss:Cell>",
-      @mock.testcase{|builder, ns_proc|
-            cell = Excel::Cell.new(1.1)
-            cell.to_xml( builder,ns_proc)
-    })
-    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"Number\">281474976710656</ss:Data>\n  </ss:Cell>",
-      @mock.testcase{|builder, ns_proc|
-            cell = Excel::Cell.new(281474976710656) #Bignum
-            cell.to_xml( builder,ns_proc)
-    })
-  end
-  def test_content_with_type
-    assert_equal("<ss:Cell>\n    <ss:Data ss:Type=\"String\">1</ss:Data>\n  </ss:Cell>",
-      @mock.testcase{|builder, ns_proc|
-            cell = Excel::Cell.new(1, :string => true)
-            cell.to_xml( builder,ns_proc)
-    })
-  end #def test_content
- 
-end #class Test_Cell_xlm
-
-class Test_Cell_xls < Test::Unit::TestCase
-  def setup()
-    wb = Excel::Excel.instance.xl.Workbooks.Add #Includes 3 worksheets
-    @ws = wb.ActiveSheet
-  end
-  def test_content_string_xls
-    cell = Excel::Cell.new('content')
-    cell_ole = cell.to_xls(@ws.Cells(1,1))    
-    assert_instance_of( WIN32OLE, cell_ole)    
-    assert_equal(XLS_ENCODING, cell_ole.value.encoding)
-    assert_equal('content', cell_ole.value)
-    assert_equal('@', cell_ole.NumberFormat)
-    
-  end #def test_content_string_xls
-  def test_content_number
-    cell_ole = Excel::Cell.new(1).to_xls(@ws.Cells(1,1))
-    assert_equal(1, cell_ole.value)
-    assert_equal(XLS_ENCODING, cell_ole.NumberFormat.encoding)
-    assert_equal("Standard".encode(XLS_ENCODING), cell_ole.NumberFormat)
-
-    cell_ole = Excel::Cell.new(1.1).to_xls(@ws.Cells(1,2))
-    assert_equal(1.1, cell_ole.value)
-    assert_equal("Standard".encode(XLS_ENCODING), cell_ole.NumberFormat)
-
-    #Bignum
-    cell_ole = Excel::Cell.new(281474976710656).to_xls(@ws.Cells(1,3))
-    assert_equal(281474976710656, cell_ole.value)
-    assert_equal("Standard".encode(XLS_ENCODING), cell_ole.NumberFormat)
-  end
-  def test_content_with_type
-    cell_ole = Excel::Cell.new(1, :string => true ).to_xls(@ws.Cells(1,1))
-    assert_equal('1', cell_ole.value)
-    assert_equal('@', cell_ole.NumberFormat)
-  end #def test_content
-end #class Test_Cell_xls
 
 class Test_Style < Test::Unit::TestCase
   def setup()