workbook 0.8.1 → 0.8.2

data/lib/workbook/writers/html_writer.rb

@@ -1,36 +1,34 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
-require 'spreadsheet'
+
+require "spreadsheet"
 
 module Workbook
   module Writers
     module HtmlWriter
-
       # Generates an HTML table ()
       #
       # @param [Hash] options A hash with options
       # @return [String] A String containing the HTML code
-      def to_html options={}
-        builder = Nokogiri::XML::Builder.new do |doc|
+      def to_html options = {}
+        builder = Nokogiri::XML::Builder.new { |doc|
           doc.html {
             doc.body {
-              self.each{|sheet|
-                doc.h1 {
+              each do |sheet|
+                doc.h1 do
                   doc.text sheet.name
-                }
-                sheet.each{|table|
-                  doc.h2 {
+                end
+                sheet.each do |table|
+                  doc.h2 do
                     doc.text table.name
-                  }
+                  end
                   doc << table.to_html(options)
-                }
-              }
+                end
+              end
             }
           }
-        end
-        return builder.doc.to_xhtml
+        }
+        builder.doc.to_xhtml
       end
 
       # Write the current workbook to HTML format
@@ -39,9 +37,9 @@ module Workbook
       # @param [Hash] options   see #to_xls
       # @return [String] filename
 
-      def write_to_html filename="#{title}.html", options={}
-        File.open(filename, 'w') {|f| f.write(to_html(options)) }
-        return filename
+      def write_to_html filename = "#{title}.html", options = {}
+        File.open(filename, "w") { |f| f.write(to_html(options)) }
+        filename
       end
     end
 
@@ -50,16 +48,16 @@ module Workbook
       #
       # @param [Hash] options A hash with options
       # @return [String] A String containing the HTML code, most importantly `:style_with_inline_css` (default false)
-      def to_html options={}
-        options = {:style_with_inline_css=>false}.merge(options)
-        builder = Nokogiri::XML::Builder.new do |doc|
+      def to_html options = {}
+        options = {style_with_inline_css: false}.merge(options)
+        builder = Nokogiri::XML::Builder.new { |doc|
           doc.table do
             doc.thead do
               if header
                 doc.tr do
                   header.each do |cell|
                     th_options = build_cell_options cell, options.merge(classnames: [cell.to_sym], data: {key: cell.to_sym})
-                    unless cell.value.class == Workbook::NilValue
+                    unless cell.value.instance_of?(Workbook::NilValue)
                       doc.th(th_options) do
                         doc.text cell.value
                       end
@@ -69,12 +67,12 @@ module Workbook
               end
             end
             doc.tbody do
-              self.each do |row|
+              each do |row|
                 unless row.header?
                   doc.tr do
                     row.each do |cell|
                       td_options = build_cell_options cell, options
-                      unless cell.value.class == Workbook::NilValue
+                      unless cell.value.instance_of?(Workbook::NilValue)
                         doc.td(td_options) do
                           doc.text cell.value
                         end
@@ -85,24 +83,22 @@ module Workbook
               end
             end
           end
-        end
-        return builder.doc.to_xhtml
+        }
+        builder.doc.to_xhtml
       end
 
-      def build_cell_options cell, options={}
+      def build_cell_options cell, options = {}
         classnames = cell.format.all_names
-        classnames = classnames + options[:classnames] if options[:classnames]
+        classnames += options[:classnames] if options[:classnames]
         classnames = classnames.join(" ").strip
-        td_options = classnames != "" ? {:class=>classnames} : {}
-        if options[:data]
-          options[:data].each do |key, value|
-            td_options = td_options.merge({("data-#{key}".to_sym) => value})
-          end
+        td_options = classnames != "" ? {class: classnames} : {}
+        options[:data]&.each do |key, value|
+          td_options = td_options.merge({"data-#{key}".to_sym => value})
         end
-        td_options = td_options.merge({:style=>cell.format.to_css}) if options[:style_with_inline_css] and cell.format.to_css != ""
-        td_options = td_options.merge({:colspan=>cell.colspan}) if cell.colspan
-        td_options = td_options.merge({:rowspan=>cell.rowspan}) if cell.rowspan
-        return td_options
+        td_options = td_options.merge({style: cell.format.to_css}) if options[:style_with_inline_css] && (cell.format.to_css != "")
+        td_options = td_options.merge({colspan: cell.colspan}) if cell.colspan
+        td_options = td_options.merge({rowspan: cell.rowspan}) if cell.rowspan
+        td_options
       end
     end
   end

data/lib/workbook/writers/json_table_writer.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
-require 'json'
+
+require "json"
 
 module Workbook
   module Writers
@@ -11,7 +10,7 @@ module Workbook
       #
       # @param [Hash] options
       # @return [String] json string
-      def to_json options={}
+      def to_json options = {}
         JSON.generate(to_array_of_hashes_with_values(options))
       end
 
@@ -19,9 +18,8 @@ module Workbook
       #
       # @param [Hash] options
       # @return [Array<Hash>] array with hashes (comma separated values in a string)
-      def to_array_of_hashes_with_values options={}
-        array_of_hashes = self.collect{|a| a.to_hash_with_values unless a.header?}.compact
-        return array_of_hashes
+      def to_array_of_hashes_with_values options = {}
+        collect { |a| a.to_hash_with_values unless a.header? }.compact
       end
 
       # Write the current workbook to JSON format
@@ -29,11 +27,10 @@ module Workbook
       # @param [String] filename
       # @param [Hash] options   see #to_json
       # @return [String] filename
-      def write_to_json filename="#{title}.json", options={}
-        File.open(filename, 'w') {|f| f.write(to_json(options)) }
-        return filename
+      def write_to_json filename = "#{title}.json", options = {}
+        File.open(filename, "w") { |f| f.write(to_json(options)) }
+        filename
       end
-
     end
   end
 end

data/lib/workbook/writers/xls_writer.rb

@@ -1,30 +1,28 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
-require 'spreadsheet'
+
+require "spreadsheet"
 
 module Workbook
   module Writers
     module XlsWriter
-
       # Generates an Spreadsheet (from the spreadsheet gem) in order to build an xls
       #
       # @param [Hash] options A hash with options (unused so far)
       # @return [Spreadsheet] A Spreadsheet object, ready for writing or more lower level operations
-      def to_xls options={}
+      def to_xls options = {}
         book = init_spreadsheet_template
-        self.each_with_index do |s,si|
+        each_with_index do |s, si|
           xls_sheet = xls_sheet(si)
           xls_sheet.name = s.name
 
           s.table.each_with_index do |r, ri|
-            xls_sheet.row(ri).height= r.format[:height] if r.format
+            xls_sheet.row(ri).height = r.format[:height] if r.format
             r.each_with_index do |c, ci|
               if c
                 if r.first?
-                  xls_sheet.columns[ci] ||= Spreadsheet::Column.new(ci,nil)
-                  xls_sheet.columns[ci].width= c.format[:width]
+                  xls_sheet.columns[ci] ||= Spreadsheet::Column.new(ci, nil)
+                  xls_sheet.columns[ci].width = c.format[:width]
                 end
                 xls_sheet.row(ri)[ci] = c.value
                 xls_sheet.row(ri).set_format(ci, format_to_xls_format(c.format))
@@ -32,12 +30,11 @@ module Workbook
             end
           end
           (xls_sheet.last_row_index + 1 - s.table.count).times do |time|
-            row_to_remove = s.table.count+time
-            remove_row(xls_sheet,row_to_remove)
+            row_to_remove = s.table.count + time
+            remove_row(xls_sheet, row_to_remove)
           end
           xls_sheet.updated_from(s.table.count)
           xls_sheet.dimensions
-
         end
         # kind of a hack, deleting by popping from xls worksheet results in errors in MS Excel (not LibreOffice)
         # book.worksheets.pop(book.worksheets.count - self.count) if book.worksheets and book.worksheets.count > self.count
@@ -46,10 +43,10 @@ module Workbook
             xls_sheet.visibility = :visible
           else
             xls_sheet.visibility = :strong_hidden
-            #also make sure all data is removed, in case someone finds out about this 'trick'
+            # also make sure all data is removed, in case someone finds out about this 'trick'
             xls_sheet.name = "RemovedSheet#{si}"
             (xls_sheet.last_row_index + 1).times do |row_index|
-              remove_row(xls_sheet,row_index)
+              remove_row(xls_sheet, row_index)
             end
           end
         end
@@ -58,20 +55,17 @@ module Workbook
         book
       end
 
-
-
       # Generates an Spreadsheet (from the spreadsheet gem) in order to build an XlS
       #
       # @param [Workbook::Format, Hash] f A Workbook::Format or hash with format-options (:font_weight, :rotation, :background_color, :number_format, :text_direction, :color, :font_family)
       # @return [Spreadsheet::Format] A Spreadsheet format-object, ready for writing or more lower level operations
       def format_to_xls_format f
-        xlsfmt = nil
         unless f.is_a? Workbook::Format
           f = Workbook::Format.new f
         end
         xlsfmt = f.return_raw_for Spreadsheet::Format
         unless xlsfmt
-          xlsfmt=Spreadsheet::Format.new :weight=>f[:font_weight]
+          xlsfmt = Spreadsheet::Format.new weight: f[:font_weight]
           xlsfmt.rotation = f[:rotation] if f[:rotation]
           xlsfmt.pattern_fg_color = html_color_to_xls_color(f[:background_color]) if html_color_to_xls_color(f[:background_color])
           xlsfmt.pattern = 1 if html_color_to_xls_color(f[:background_color])
@@ -83,7 +77,7 @@ module Workbook
           xlsfmt.font.color = color if color
           f.add_raw xlsfmt
         end
-        return xlsfmt
+        xlsfmt
       end
 
       # Parses right font-family name
@@ -91,20 +85,20 @@ module Workbook
       # @param [Workbook::Format, hash] format to parse
       def parse_font_family(format)
         font = format[:font_family].to_s.split.last
-        valid_values = [:none,:roman,:swiss,:modern,:script,:decorative]
+        valid_values = [:none, :roman, :swiss, :modern, :script, :decorative]
         if valid_values.include?(font)
-          return font
+          font
         elsif valid_values.include?(font.to_s.downcase.to_sym)
-          return font.to_s.downcase.to_sym
+          font.to_s.downcase.to_sym
         else
           font = font.to_s.downcase.strip
           translation = {
-            "arial"=>:swiss,
-            "times"=>:roman,
-            "times new roman"=>:roman
+            "arial" => :swiss,
+            "times" => :roman,
+            "times new roman" => :roman
           }
           tfont = translation[font]
-          return tfont ? tfont : :none
+          tfont || :none
         end
       end
 
@@ -112,40 +106,40 @@ module Workbook
       #
       # @param [String] filename
       # @param [Hash] options   see #to_xls
-      def write_to_xls filename="#{title}.xls", options={}
+      def write_to_xls filename = "#{title}.xls", options = {}
         if to_xls(options).write(filename)
-          return filename
+          filename
         end
       end
 
       def xls_sheet a
         if xls_template.worksheet(a)
-          return xls_template.worksheet(a)
+          xls_template.worksheet(a)
         else
           xls_template.create_worksheet
-          self.xls_sheet a
+          xls_sheet a
         end
       end
 
       def xls_template
-        return template.raws[Spreadsheet::Excel::Workbook] ? template.raws[Spreadsheet::Excel::Workbook] : template.raws[Spreadsheet::Workbook]
+        template.raws[Spreadsheet::Excel::Workbook] || template.raws[Spreadsheet::Workbook]
       end
 
       def init_spreadsheet_template
-        if self.xls_template.is_a? Spreadsheet::Workbook
-          return self.xls_template
+        if xls_template.is_a? Spreadsheet::Workbook
+          xls_template
         else
           t = Spreadsheet::Workbook.new
           template.add_raw t
-          return t
+          t
         end
       end
 
       private
 
-      def remove_row(xls_sheet,row_index)
+      def remove_row(xls_sheet, row_index)
         xls_sheet.row(row_index).each_with_index do |c, ci|
-          xls_sheet.row(row_index)[ci]=nil
+          xls_sheet.row(row_index)[ci] = nil
         end
         xls_sheet.delete_row(row_index)
         xls_sheet.row_updated(row_index, xls_sheet.row(row_index))

data/lib/workbook/writers/xlsx_writer.rb

@@ -1,37 +1,51 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-# frozen_string_literal: true
-require 'axlsx'
-require 'workbook/readers/xls_shared'
+require "axlsx"
+require "workbook/readers/xls_shared"
 
 module Workbook
   module Writers
     module XlsxWriter
-
+      CELL_TYPE_MAPPING = {
+        decimal: :integer,
+        integer: :integer,
+        float: :float,
+        string: :text,
+        time: :time,
+        date: :date,
+        datetime: :time,
+        boolean: :boolean,
+        nil: :string
+      }
       # Generates an axlsx doc, ready for export to XLSX
       #
       # @param [Hash] options A hash with options (unused so far)
       # @return [Axlsx::Package] An object, ready for writing or more lower level operations
-      def to_xlsx options={}
+      def to_xlsx options = {}
         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|
+        book.worksheets.pop(book.worksheets.count - count) if book.worksheets && (book.worksheets.count > count)
+        each_with_index do |s, si|
           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 = 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|
               xlsx_row.add_cell(c.value) unless xlsx_row_a[ci]
               xlsx_cell = xlsx_row_a[ci]
+
+              xlsx_cell.type = CELL_TYPE_MAPPING[c.cell_type]
               xlsx_cell.value = c.value
-              # if c.format?
-                # format_to_xlsx_format(c.format) unless c.format.raws[Fixnum]
-                # xlsx_cell.style = c.format.raws[Fixnum]
-              # end
+
+              if c.format? && c.format.raws[Integer]
+                xlsx_cell.style = c.format.raws[Integer]
+              elsif c.format? && !(c.value.is_a?(Date) || !c.value.is_a?(DateTime) || !c.value.is_a?(Time))
+                # TODO: disable formatting
+                # xlsx_cell.style = format_to_xlsx_format(c.format)
+              end
             end
             xlsx_sheet.send(:update_column_info, xlsx_row.cells, [])
           end
@@ -54,39 +68,39 @@ module Workbook
       #
       # @param [String] filename
       # @param [Hash] options   see #to_xlsx
-      def write_to_xlsx filename="#{title}.xlsx", options={}
+      def write_to_xlsx filename = "#{title}.xlsx", options = {}
         if to_xlsx(options).serialize(filename)
-          return filename
+          filename
         end
       end
 
       def xlsx_sheet a
         if xlsx_template.workbook.worksheets[a]
-          return xlsx_template.workbook.worksheets[a]
+          xlsx_template.workbook.worksheets[a]
         else
           xlsx_template.workbook.add_worksheet
-          self.xlsx_sheet a
+          xlsx_sheet a
         end
       end
 
       def xlsx_template
-        return template.raws[Axlsx::Package]
+        template.raws[Axlsx::Package]
       end
 
       def init_xlsx_spreadsheet_template
-        if self.xlsx_template.is_a? Axlsx::Package
-          return self.xlsx_template
+        if xlsx_template.is_a? Axlsx::Package
+          xlsx_template
         else
           t = Axlsx::Package.new
           template.add_raw t
           # template.set_default_formats!
-          return t
+          t
         end
       end
 
       def formats_to_xlsx_format
-        template.formats.each do |n,v|
-          v.each do | t,s |
+        template.formats.each do |n, v|
+          v.each do |t, s|
             format_to_xlsx_format(s)
           end
         end
@@ -99,20 +113,22 @@ module Workbook
       def format_to_xlsx_format f
         f = make_sure_f_is_a_workbook_format f
 
-        xlsfmt={}
-        xlsfmt[:fg_color] = "FF#{f[:color].to_s.upcase}".gsub("#",'') if f[:color]
-        xlsfmt[:b] = true if f[:font_weight].to_s == "bold" or f[:font_weight].to_i >= 600 or f[:"font_style"].to_s.match "oblique"
+        xlsfmt = {}
+        xlsfmt[:fg_color] = "FF#{f[:color].to_s.upcase}".delete("#") if f[:color]
+        xlsfmt[:b] = true if (f[:font_weight].to_s == "bold") || (f[:font_weight].to_i >= 600) || f[:font_style].to_s.match("oblique")
         xlsfmt[:i] = true if f[:font_style].to_s == "italic"
-        xlsfmt[:u] = true if f[:text_decoration].to_s.match("underline")
+        xlsfmt[:u] = true if f[:text_decoration].to_s.include?("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)
+        style_reference = init_xlsx_spreadsheet_template.workbook.styles.add_style(xlsfmt)
+
+        f.add_raw style_reference
         f.add_raw xlsfmt
 
-        return xlsfmt
+        style_reference
       end
     end
   end

data/lib/workbook.rb

@@ -1,30 +1,31 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
-require_relative 'workbook/modules/cache'
-require_relative 'workbook/modules/cell'
-require_relative 'workbook/types/date'
-require_relative 'workbook/book'
-require_relative 'workbook/sheet'
-require_relative 'workbook/table'
-require_relative 'workbook/nil_value'
-require_relative 'workbook/row'
-require_relative 'workbook/cell'
-require_relative 'workbook/format'
-require_relative 'workbook/template'
-require_relative 'workbook/version'
-require_relative 'workbook/column'
+
+require_relative "workbook/modules/cache"
+require_relative "workbook/modules/cell"
+require_relative "workbook/types/date"
+require_relative "workbook/book"
+require_relative "workbook/sheet"
+require_relative "workbook/table"
+require_relative "workbook/nil_value"
+require_relative "workbook/row"
+require_relative "workbook/cell"
+require_relative "workbook/format"
+require_relative "workbook/template"
+require_relative "workbook/version"
+require_relative "workbook/column"
 
 module Workbook
   class << self
     def caching_enabled?
       @@caching_enabled ||= true
     end
+
     # Disable caching globally (wherever applicable)
     def disable_caching!
       @@caching_enabled = false
     end
+
     # Enable caching globally (wherever applicable)
     def enable_caching!
       @@caching_enabled = true

data/test/helper.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-require 'minitest/autorun'
-# require 'test/unit'
-require 'rubygems'
-require File.join(File.dirname(__FILE__), '../lib/workbook')
+require "simplecov"
+SimpleCov.start
+
+require "minitest/autorun"
+require "rubygems"
+require File.join(File.dirname(__FILE__), "../lib/workbook")