workbook 0.4.9 → 0.4.10

data/lib/workbook/modules/raw_objects_storage.rb

@@ -5,8 +5,9 @@ module Workbook
     module RawObjectsStorage
 
       # A raw is a 'raw' object, representing a workbook, or cell, or whatever... in a particular format (defined by its class)
-      def add_raw raw_object
-        raws[raw_object.class]=raw_object
+      def add_raw raw_object, options={}
+        class_of_obj = options[:raw_object_class] ? options[:raw_object_class] : raw_object.class
+        raws[class_of_obj]=raw_object
       end
 
       # Returns true if there is a template for a certain class, otherwise false

data/lib/workbook/readers/xlsx_reader.rb

@@ -1,5 +1,5 @@
 # -*- encoding : utf-8 -*-
-require 'rubyXL'
+require 'roo'
 require 'workbook/readers/xls_shared'
 
 
@@ -16,55 +16,22 @@ module Workbook
       end
       def load_xlsx file_obj
         file_obj = file_obj.path if file_obj.is_a? File
-        sp = RubyXL::Parser.parse(file_obj)
-        template.add_raw sp
+        # file_obj = file_obj.match(/^\/(.*)/) ? file_obj : "./#{file_obj}"
+        # p "opening #{file_obj}"
+        sp = Roo::Excelx.new(file_obj)
+        template.add_raw sp, raw_object_class: Roo::Spreadsheet
         parse_xlsx sp
       end
 
-      def parse_xlsx xlsx_spreadsheet=template.raws[RubyXL::Workbook], options={}
+      def parse_xlsx xlsx_spreadsheet=template.raws[Roo::Spreadsheet], options={}
         options = {:additional_type_parsing=>false}.merge options
-        #number_of_worksheets = xlsx_spreadsheet.worksheets.count
-        xlsx_spreadsheet.worksheets.each_with_index do |worksheet, si|
-          s = create_or_open_sheet_at(si)
-          col_widths = []
-          begin
-            col_widths = xlsx_spreadsheet.worksheets.first.cols.collect{|a| a[:attributes][:width].to_f if a[:attributes]}
-          rescue
-            # Column widths couldn't be read, no big deal...
-          end
-
-          worksheet.each_with_index do |row, ri|
-            if row
-              r = s.table.create_or_open_row_at(ri)
-              row.cells.each_with_index do |cell,ci|
-                if cell.nil?
-                  r[ci] = Workbook::Cell.new nil
-                else
-                  r[ci] = Workbook::Cell.new cell.value
-                  r[ci].parse!
-                  xls_format = cell.style_index
-                  col_width = nil
-
-                  if ri == 0
-                    col_width = col_widths[ci]
-                  end
-                  f = template.create_or_find_format_by "style_index_#{cell.style_index}", col_width
-                  f[:width]= col_width
-                  background_color = cell.fill_color
-                  background_color = (background_color.length == 8) ? background_color[2..8] : background_color #ignoring alpha for now.
-                  f[:background_color] = "##{background_color}"
-
-                  f[:number_format] = ms_formatting_to_strftime(cell.number_format)
-                  # f[:font_family] = cell.font_name
-                  # f[:color] = "##{cell.font_color}"
-
-                  f.add_raw xls_format
-
-                  r[ci].format = f
-                end
-              end
-            end
+        sheet_index = 0
+        xlsx_spreadsheet.each_with_pagename do |sheet_name, sheet|
+          s = create_or_open_sheet_at(sheet_index)
+          sheet.each_with_index do |row, rowi|
+            s.table << row
           end
+          sheet_index += 1
         end
       end
     end

data/lib/workbook/row.rb

@@ -20,7 +20,7 @@ module Workbook
       cells.each do |c|
         c = c.clone if options[:clone_cells]
         unless c.is_a? Workbook::Cell
-          c = Workbook::Cell.new(c)
+          c = Workbook::Cell.new(c, {row:self})
           c.parse!(options[:cell_parse_options]) if options[:parse_cells_on_batch_creation]
         end
         push c
@@ -62,14 +62,14 @@ module Workbook
     # Add cell
     # @param [Workbook::Cell, Numeric,String,Time,Date,TrueClass,FalseClass,NilClass] cell or value to add
     def push(cell)
-      cell = Workbook::Cell.new(cell) unless cell.class == Workbook::Cell
+      cell = Workbook::Cell.new(cell, {row:self}) unless cell.class == Workbook::Cell
       super(cell)
     end
 
     # Add cell
     # @param [Workbook::Cell, Numeric,String,Time,Date,TrueClass,FalseClass,NilClass] cell or value to add
     def <<(cell)
-      cell = Workbook::Cell.new(cell) unless cell.class == Workbook::Cell
+      cell = Workbook::Cell.new(cell,  {row:self}) unless cell.class == Workbook::Cell
       super(cell)
     end
 
@@ -108,7 +108,7 @@ module Workbook
         end
         return rv
       elsif index_or_hash.is_a? String
-        symbolized = Workbook::Cell.new(index_or_hash).to_sym
+        symbolized = Workbook::Cell.new(index_or_hash, {row:self}).to_sym
         self[symbolized]
       else
         if index_or_hash
@@ -131,7 +131,7 @@ module Workbook
       if index_or_hash.is_a? Symbol
         index = table_header_keys.index(index_or_hash)
       elsif index_or_hash.is_a? String
-        symbolized = Workbook::Cell.new(index_or_hash).to_sym
+        symbolized = Workbook::Cell.new(index_or_hash, {row:self}).to_sym
         index = table_header_keys.index(symbolized)
       end
 
@@ -145,6 +145,7 @@ module Workbook
         end
         value_celled.value=(value)
       end
+      value_celled.row = self
       super(index,value_celled)
     end
 
@@ -214,6 +215,13 @@ module Workbook
       return hash
     end
 
+    # Quick assessor to the book's template, if it exists
+    #
+    # @return [Workbook::Template]
+    def template
+      table.template if table
+    end
+
     # Returns a hash representation of this row
     #
     # it differs from #to_hash as it doesn't contain the Workbook's Workbook::Cell-objects,

data/lib/workbook/sheet.rb

@@ -34,6 +34,9 @@ module Workbook
       first
     end
 
+    # Returns the name of this sheet
+    #
+    # @return [String] the name, defaulting to "Sheet {index}" when none is set
     def name
       @name ||= "Sheet #{book.index(self)+1}"
     end

data/lib/workbook/table.rb

@@ -231,5 +231,19 @@ module Workbook
       self
     end
 
+    # Returns The dimensions of this sheet based on longest row
+    # @return [Array] x-width, y-height
+    def dimensions
+      height = self.count
+      width = self.collect{|a| a.length}.max
+      [width,height]
+    end
+
+    def columns
+      @columns ||= header.collect do |header_cell|
+        Column.new(self)
+      end
+    end
+
   end
 end

data/lib/workbook/template.rb

@@ -50,5 +50,10 @@ module Workbook
       end
       return @formats[name][variant]
     end
+
+    def set_default_formats!
+      header_fmt = create_or_find_format_by :header
+      header_fmt[:font_weight] = 'bold'
+    end
   end
 end

data/lib/workbook/types/Date.rb

@@ -1,9 +1,21 @@
-require 'workbook/cell'
+# require 'workbook/modules/cell'
 
 module Workbook
   module Types
     class Date < Date
-      include Workbook::Cell
+      include Workbook::Modules::Cell
+
+      def initialize(*args)
+        super(*args)
+      end
+
+      def value
+        self
+      end
+
+      def value= a
+        throw "#value= is no longer available"
+      end
     end
   end
 end

data/lib/workbook/types/FalseClass.rb

@@ -1,9 +1,7 @@
-require 'workbook/cell'
-
 module Workbook
   module Types
     class FalseClass < FalseClass
-      include Workbook::Cell
+      include Workbook::Modules::Cell
     end
   end
 end

data/lib/workbook/version.rb

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

data/lib/workbook/writers/xlsx_writer.rb

@@ -1,82 +1,112 @@
 # -*- encoding : utf-8 -*-
-require 'rubyXL'
+require 'axlsx'
 require 'workbook/readers/xls_shared'
 
 module Workbook
   module Writers
     module XlsxWriter
 
-      # Generates an RubyXL doc, ready for export to XLSX
+      # Generates an axlsx doc, ready for export to XLSX
       #
       # @param [Hash] options A hash with options (unused so far)
-      # @return [Spreadsheet] A Spreadsheet object, ready for writing or more lower level operations
+      # @return [Axlsx::Package] An object, ready for writing or more lower level operations
       def to_xlsx options={}
-        book = init_xlsx_spreadsheet_template
-        book.theme = RubyXL::Theme.new unless book.theme #workaround bug in rubyxl
+        formats_to_xlsx_format
+        book = init_xlsx_spreadsheet_template.workbook
         book.worksheets.pop(book.worksheets.count - self.count) if book.worksheets and book.worksheets.count > self.count
         self.each_with_index do |s,si|
-          xls_sheet = xlsx_sheet(si)
-          xls_sheet.sheet_name = s.name
-
+          xlsx_sheet = xlsx_sheet(si)
+          xlsx_sheet.name = s.name
           s.table.each_with_index do |r, ri|
+            xlsx_row = xlsx_sheet[ri] ? xlsx_sheet[ri] : xlsx_sheet.add_row
+            xlsx_row.height = 16
+            xlsx_row_a = xlsx_row.to_ary
             r.each_with_index do |c, ci|
-              xls_sheet.add_cell(ri, ci, c.value)
-
+              xlsx_row.add_cell(c.value) unless xlsx_row_a[ci]
+              xlsx_cell = xlsx_row_a[ci]
+              xlsx_cell.value = c.value
+              xlsx_cell.style = c.format.raws[Fixnum] if c.format.raws[Fixnum]
             end
+            xlsx_sheet.send(:update_column_info, xlsx_row.cells, [])
           end
-          (xls_sheet.count + 1 - s.table.count).times do |time|
-            row_to_remove = s.table.count+time
-
-            xls_sheet.delete_row(row_to_remove)
-            # xls_sheet.row_updated(row_to_remove, xls_sheet.row(row_to_remove))
+          (xlsx_sheet.rows.count - s.table.count).times do |time|
+            xlsx_sheet.rows.pop
           end
-          # xls_sheet.updated_from(s.table.count)
-          # xls_sheet.dimensions
-
         end
-        book
+        init_xlsx_spreadsheet_template
       end
 
-      # Generates an RubyXL doc, ready for export to XLSX
+      # Generates an string ready to be streamed as XLSX
       #
       # @param [Hash] options A hash with options (unused so far)
       # @return [String] A string, ready for streaming, e.g. `send_data workbook.stream_xlsx`
       def stream_xlsx options = {}
-        to_xlsx(options).stream.string
+        to_xlsx(options).to_stream.string
       end
 
-      # Write the current workbook to Microsoft Excel's new format (using the RubyXL gem)
+      # Write the current workbook to Microsoft Excel's XML format (using the Axlsx gem)
       #
       # @param [String] filename
       # @param [Hash] options   see #to_xlsx
       def write_to_xlsx filename="#{title}.xlsx", options={}
-        if to_xlsx(options).write(filename)
+        if to_xlsx(options).serialize(filename)
           return filename
         end
       end
 
       def xlsx_sheet a
-        if xlsx_template.worksheets[a]
-          return xlsx_template.worksheets[a]
+        if xlsx_template.workbook.worksheets[a]
+          return xlsx_template.workbook.worksheets[a]
         else
-          xlsx_template.create_worksheet
-          self.xls_sheet a
+          xlsx_template.workbook.add_worksheet
+          self.xlsx_sheet a
         end
       end
 
       def xlsx_template
-        return template.raws[RubyXL::Workbook]
+        return template.raws[Axlsx::Package]
       end
 
       def init_xlsx_spreadsheet_template
-        if self.xlsx_template.is_a? RubyXL::Workbook
+        if self.xlsx_template.is_a? Axlsx::Package
           return self.xlsx_template
         else
-          t = RubyXL::Workbook.new
+          t = Axlsx::Package.new
           template.add_raw t
+          template.set_default_formats!
           return t
         end
       end
+
+      def formats_to_xlsx_format
+        template.formats.each do |n,v|
+          v.each do | t,s |
+            format_to_xlsx_format(s)
+          end
+        end
+      end
+
+      def format_to_xlsx_format f
+        xlsfmt = nil
+        unless f.is_a? Workbook::Format
+          f = Workbook::Format.new f
+        end
+
+        xlsfmt={}
+        xlsfmt[:fg_color] = "#{f[:color]}00" if f[:color]
+        xlsfmt[:b] = true if f[:font_weight] == "bold" or f[:font_weight].to_i >= 600 or f[:"font_style"].to_s.match "oblique"
+        xlsfmt[:i] = true if f[:font_style] == "italic"
+        xlsfmt[:u] = true if f[:text_decoration].to_s.match("underline")
+        xlsfmt[:bg_color] = f[:background_color] if f[:background_color]
+        xlsfmt[:format_code] = strftime_to_ms_format(f[:number_format]) if f[:number_format]
+        xlsfmt[:font_name] = f[:font_family].split.first if f[:font_family]
+        xlsfmt[:family] = parse_font_family(f) if f[:font_family]
+        f.add_raw init_xlsx_spreadsheet_template.workbook.styles.add_style(xlsfmt)
+        # wb.styles{|a| p a.add_style({}).class }
+
+        f.add_raw xlsfmt
+        return xlsfmt
+      end
     end
   end
 end

data/test/test_column.rb

@@ -3,6 +3,16 @@ require File.join(File.dirname(__FILE__), 'helper')
 
 class TestColumn < Minitest::Test
 
+  def new_table
+    Workbook::Table.new([
+        ["a","b","c","d"],
+        [true,3.2,"asdf",1],
+        [true,3.2,"asdf",1],
+        [false,3.2,"asdf",1],
+        [true,3.2,"asdf",1]
+      ])
+  end
+
   def test_init
     c = Workbook::Column.new
     assert_equal(Workbook::Column, c.class)
@@ -21,4 +31,24 @@ class TestColumn < Minitest::Test
     assert_equal(Workbook::Table.new, c.table)
     assert_raises(ArgumentError) { c.table = false }
   end
+
+  def test_index
+    t = new_table
+    assert_equal(t.columns.first.index, 0)
+    assert_equal(t.columns.last.index, 3)
+  end
+
+  def test_column_type
+    t = new_table
+    assert_equal([:boolean, :float, :string, :integer], t.columns.collect{|a| a.column_type})
+    t = new_table
+    t.last.last.value = 1.1
+    assert_equal([:boolean, :float, :string, :string], t.columns.collect{|a| a.column_type})
+    t = new_table
+    t[2][3] = nil
+    assert_equal([:boolean, :float, :string, :integer], t.columns.collect{|a| a.column_type})
+    t = new_table
+    t[2].delete_at(3)
+    assert_equal([:boolean, :float, :string, :integer], t.columns.collect{|a| a.column_type})
+  end
 end

data/test/{test_cell.rb → test_modules_cell.rb}

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 require File.join(File.dirname(__FILE__), 'helper')
 
-class TestCell < Minitest::Test
+class TestModulesCell < Minitest::Test
 
 
   def test_init
@@ -115,4 +115,11 @@ class TestCell < Minitest::Test
     assert_equal(3,c.rowspan)
     assert_equal(nil,c.colspan)
   end
+
+  def cell_type
+    {1 => :integer, 3.2 => :float, true => :boolean, "asdf" => :string}.each do |k,v|
+      c = Workbook::Cel.new(k)
+      assert_equal(v,c.cell_type)
+    end
+  end
 end

data/test/test_readers_xlsx_reader.rb

@@ -9,7 +9,7 @@ module Readers
       assert_equal(90588,w.sheet.table[2][:b].value)
       assert_equal(DateTime.new(2011,11,15),w.sheet.table[3][:d].value)
       # assert_equal("#CCFFCC",w.sheet.table[3][:c].format[:background_color]) #colour compatibility turned off for now...
-      # assert_equal(8,w.sheet.table.first[:b].format[:width].round)
+      #assert_equal(8,w.sheet.table.first[:b].format[:width].round)
       # assert_equal(4,w.sheet.table.first[:a].format[:width].round)
       # assert_equal(25,w.sheet.table.first[:c].format[:width].round)
     end
@@ -29,11 +29,5 @@ module Readers
       assert_equal(nil,w.ms_formatting_to_strftime(nil));
       assert_equal(nil,w.ms_formatting_to_strftime(""));
     end
-    # def test_monkey_patched_ruby_xl_is_date_format?
-    #   w = RubyXL::Workbook.new
-    #   assert_equal(false, w.is_date_format?(nil))
-    #   assert_equal(false, w.is_date_format?(""))
-    #   assert_equal(true, w.is_date_format?("D-M-YYY"))
-    # end
   end
 end