workbook 0.8.1 → 0.8.2

data/lib/workbook/sheet.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
+
 module Workbook
   # A Sheet is a container of tables
-  class Sheet < Array
-
+  class Sheet
+    include Enumerable
     # Initialize a new sheet
     #
     # @param [Workbook::Table, Array<Array>] table   The first table of this sheet
     # @param [Workbook::Book] book                   The book this sheet belongs to
     # @param [Hash] options                          are forwarded to Workbook::Table.new
     # @return [Workbook::Sheet] (self)
-    def initialize table=Workbook::Table.new([], self), book=nil, options={}
-      if table.is_a? Workbook::Table
-        push table
+    def initialize table = Workbook::Table.new([], self), book = nil, options = {}
+      @tables = []
+
+      if table.is_a?(Workbook::Table)
+        @tables.push table
       else
-        push Workbook::Table.new(table, self, options)
+        @tables.push(Workbook::Table.new(table, self, options))
       end
       self.book = book
-      return self
     end
 
     # Returns true if the first table of this sheet contains anything
@@ -33,79 +33,88 @@ module Workbook
     #
     # @return [Workbook::Table] the first table of this sheet
     def table
-      first
+      @tables.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}"
+      @name ||= "Sheet #{book.index(self) + 1}"
     end
 
     # Set the name of this sheet
     #
     # @param [String] the new name of the sheet
     # @return [String] the given name
-    def name= name
-      @name = name
-    end
+    attr_writer :name
 
     # Set the first table of this sheet with a table or array of cells/values
     # @param [Workbook::Table, Array<Array>] table   The new first table of this sheet
     # @param [Hash] options                          are forwarded to Workbook::Table.new
     # @return [Workbook::Table] the first table of this sheet
-    def table= table, options={}
-      if table.is_a? Workbook::Table
-        self[0] = table
+    def table= table, options = {}
+      @tables[0] = if table.is_a? Workbook::Table
+        table
       else
-        self[0] = Workbook::Table.new(table, self, options)
+        Workbook::Table.new(table, self, options)
       end
-      return table
     end
 
-    # Returns the book this sheet belongs to
+    # Returns the Book this Sheet belongs to
     #
     # @return [Workbook::Book] the book this sheet belongs to
     def book
-      if @book
-        return @book
-      else
-        self.book = Workbook::Book.new(self)
-        return @book
-      end
+      @book || (self.book = Workbook::Book.new(self))
+    end
+
+    # Returns a existing or new Table at the specified index
+    #
+    # @return [Workbook::Table]
+    def [] index
+      @tables[index] ||= Workbook::Table.new([], self)
+    end
+
+    # Inserts a new Table at the specified index
+    #
+    # @param [Integer] index of the table
+    # @param [Workbook::Table, Array<Array>] table   The new first table of this sheet
+    #
+    # @return [Workbook::Table]
+    def []= index, value
+      table_to_insert = value.is_a?(Workbook::Table) ? value : Workbook::Table.new
+      table_to_insert.sheet = self
+      @tables[index] = table_to_insert
     end
 
-    def book= b
-      @book = b
+    # Returns an enumerator
+    def each(...)
+      @tables.each(...)
     end
 
+    attr_writer :book
+
     # Removes all lines from this table
     #
     # @return [Workbook::Table] (self)
     def delete_all
-      self.delete_if{|b| true}
+      @tables.delete_if { |b| true }
     end
 
     # clones itself *and* the tables it contains
     #
     # @return [Workbook::Sheet] The cloned sheet
     def clone
-      s = self
-      c = super
-      c.delete_all
-      s.each{|t| c << t.clone}
-      return c
+      clone = super
+      @tables = @tables.map(&:clone)
+      clone
     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
+      self[index]
     end
   end
 end

data/lib/workbook/table.rb

@@ -1,30 +1,35 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
-require 'workbook/modules/diff_sort'
-require 'workbook/writers/csv_table_writer'
-require 'workbook/writers/json_table_writer'
-require 'workbook/writers/html_writer'
 
+require "workbook/modules/diff_sort"
+require "workbook/writers/csv_table_writer"
+require "workbook/writers/json_table_writer"
+require "workbook/writers/html_writer"
 
 module Workbook
   # A table is a container of rows and keeps track of the sheet it belongs to and which row is its header. Additionally suport for CSV writing and diffing with another table is included.
-  class Table < Array
+  class Table
+    include Enumerable
+    extend Forwardable
+
     include Workbook::Modules::TableDiffSort
     include Workbook::Writers::CsvTableWriter
     include Workbook::Writers::JsonTableWriter
     include Workbook::Writers::HtmlTableWriter
 
+    delegate [:first, :last, :pop, :delete_at, :each, :collect, :each_with_index, :count, :index, :delete_if, :include?] => :@rows
+
     attr_accessor :name
+    attr_reader :rows
 
-    def initialize row_cel_values=[], sheet=nil, options={}
-      row_cel_values = [] if row_cel_values == nil
-      row_cel_values.each_with_index do |r,ri|
+    def initialize row_cel_values = [], sheet = nil, options = {}
+      @rows = []
+      row_cel_values = [] if row_cel_values.nil?
+      row_cel_values.each_with_index do |r, ri|
         if r.is_a? Workbook::Row
           r.table = self
         else
-          r = Workbook::Row.new(r,self, options)
+          r = Workbook::Row.new(r, self, options)
         end
         define_columns_with_row(r) if ri == 0
       end
@@ -44,9 +49,9 @@ module Workbook
     #
     # @return [Workbook::Row] The header
     def header
-      if defined?(@header) and @header == false
+      if defined?(@header) && (@header == false)
         false
-      elsif defined?(@header) and @header
+      elsif defined?(@header) && @header
         @header
       else
         first
@@ -59,10 +64,10 @@ module Workbook
     # @param [Workbook::Row, Integer] h should be the row or the index of this table's row
     # @return [Workbook::Row] The header
     def header= h
-      if h.is_a? Numeric
-        @header = self[h]
+      @header = if h.is_a? Numeric
+        self[h]
       else
-        @header = h
+        h
       end
     end
 
@@ -70,7 +75,7 @@ module Workbook
     #
     # @return [Integer] The index of the header row (typically 0)
     def header_row_index
-      self.index(self.header)
+      @rows.map(&:object_id).index(header.object_id)
     end
 
     def define_columns_with_row(r)
@@ -83,16 +88,15 @@ module Workbook
     #
     # @param [Array, Workbook::Row] cell_values is an array or row of cell values
     # @return [Workbook::Row] the newly created row
-    def new_row cell_values=[]
-      r = Workbook::Row.new(cell_values,self)
-      return r
+    def new_row cell_values = []
+      Workbook::Row.new(cell_values, self)
     end
 
     def create_or_open_row_at index
       r = self[index]
-      if r == nil
+      if r.nil?
         r = Workbook::Row.new
-        r.table=(self)
+        r.table = self
       end
       r
     end
@@ -101,28 +105,40 @@ module Workbook
     #
     # @return [Workbook::Table] self
     def remove_empty_lines!
-      self.delete_if{|r| r.nil? or r.compact.empty?}
+      delete_if { |r| r.nil? || r.compact.empty? }
       self
     end
 
     # Add row
-    # @param [Workbook::Table, Array] row to add
-    def push(row)
-      row = Workbook::Row.new(row) if row.class == Array
-      super(row)
-      row.set_table(self)
+    # @param [Workbook::Table, Array] row(s) to add
+    def push(*args)
+      args.each do |arg|
+        self.<<(arg)
+      end
     end
+    alias_method :append, :push
 
     # Add row
     # @param [Workbook::Table, Array] row to add
     def <<(row)
-      row = Workbook::Row.new(row) if row.class == Array
-      super(row)
+      row = row.is_a?(Workbook::Row) ? row : Workbook::Row.new(row)
       row.set_table(self)
+      @rows << row
+    end
+
+    # Insert row
+    # @param [Integer] index where to add
+    # @param [Array, Workbook::Row] row(s) to add
+    def insert index, *rows
+      rows.each_with_index do |row, i|
+        row = row.is_a?(Workbook::Row) ? row : Workbook::Row.new(row)
+        row.set_table(self)
+        row.insert(index + i, row)
+      end
     end
 
     def has_contents?
-      self.clone.remove_empty_lines!.count != 0
+      clone.remove_empty_lines!.count != 0
     end
 
     # Returns true if the row exists in this table
@@ -131,42 +147,43 @@ module Workbook
     # @return [Boolean] whether the row exist in this table
     def contains_row? row
       raise ArgumentError, "table should be a Workbook::Row (you passed a #{t.class})" unless row.is_a?(Workbook::Row)
-      self.collect{|r| r.object_id}.include? row.object_id
+      collect { |r| r.object_id }.include? row.object_id
     end
 
     # Returns the sheet this table belongs to, creates a new sheet if none exists
     #
     # @return [Workbook::Sheet] The sheet this table belongs to
     def sheet
-      return @sheet if defined?(@sheet) and !@sheet.nil?
-      self.sheet= Workbook::Sheet.new(self)
+      return @sheet if defined?(@sheet) && !@sheet.nil?
+      self.sheet = Workbook::Sheet.new(self)
     end
 
     # Returns the sheet this table belongs to, creates a new sheet if none exists
     #
     # @param [Workbook::Sheet] sheet this table belongs to
     # @return [Workbook::Sheet] The sheet this table belongs to
-    def sheet= sheet
-      @sheet = sheet
-    end
+    attr_writer :sheet
 
     # Removes all lines from this table
     #
     # @return [Workbook::Table] (self)
     def delete_all
-      self.delete_if{|b| true}
+      delete_if { |b| true }
     end
 
     # clones itself *and* the rows it contains
     #
     # @return [Workbook::Table] The cloned table
     def clone
-      t = self
-      c = super
-      c.delete_all
-      t.each{|r| c << r.clone}
-      c.header = c[header_row_index] if header_row_index
-      return c
+      table_clone = super
+      @rows = @rows.map { |row|
+        cloned_row = row.clone
+        cloned_row.set_table(self)
+        cloned_row
+      }
+      self.header = @rows[header_row_index] if header_row_index
+      table_clone.header = table_clone.rows[header_row_index] if header_row_index
+      table_clone
     end
 
     # Overrides normal Array's []-function with support for symbols that identify a column based on the header-values
@@ -175,19 +192,25 @@ module Workbook
     #   table[0] #=> <Row [a,2,3,4]> (first row)
     #   table["A1"] #=> <Cell value="a"> (first cell of first row)
     #
-    # @param [Fixnum, String] index_or_string to reference to either the row, or the cell
+    # @param [Integer, String] index_or_string to reference to either the row, or the cell
     # @return [Workbook::Row, Workbook::Cell, nil]
     def [] index_or_string
       if index_or_string.is_a? String
         match = index_or_string.match(/([A-Z]+)([0-9]*)/i)
         col_index = Workbook::Column.alpha_index_to_number_index(match[1])
-        row_index = match[2].to_i - 1
-        return self[row_index][col_index]
+        if match[2] == ""
+          columns[col_index]
+        else
+          row_index = match[2].to_i - 1
+          @rows[row_index][col_index]
+        end
+      elsif index_or_string.is_a? Symbol
+        header[index_or_string].column
       elsif index_or_string.is_a? Range
-        collection = to_a[index_or_string].collect{|a| a.clone}
-        return Workbook::Table.new collection
+        collection = @rows[index_or_string].collect { |a| a.clone }
+        Workbook::Table.new collection
       elsif index_or_string.is_a? Integer
-        return to_a[index_or_string]
+        @rows[index_or_string]
       end
     end
 
@@ -198,7 +221,7 @@ module Workbook
     #   `table[0] = <Row [a,2,3,4]>` (set first row)
     #   `table["A1"] = 2` (set first cell of first row to 2)
     #
-    # @param [Fixnum, String] index_or_string to reference to either the row, or the cell
+    # @param [Integer, String] index_or_string to reference to either the row, or the cell
     # @param [Workbook::Table, Array] new_value to set
     # @return [Workbook::Cell, nil]
     def []= index_or_string, new_value
@@ -206,65 +229,66 @@ module Workbook
         match = index_or_string.upcase.match(/([A-Z]*)([0-9]*)/)
         cell_index = Workbook::Column.alpha_index_to_number_index(match[1])
         row_index = match[2].to_i - 1
-        self[row_index][cell_index].value = new_value
+        @rows[row_index][cell_index].value = new_value
       else
-        row = new_value
-        row = Workbook::Row.new(row) unless row.is_a? Workbook::Row
-        super(index_or_string,row)
-        row.set_table(self)
+        row = new_value.is_a?(Workbook::Row) ? new_value : Workbook::Row.new(new_value)
+        row.table = self
       end
     end
 
+    def == other
+      to_csv == other.to_csv
+    end
+
     # remove all the trailing empty-rows (returning a trimmed clone)
     #
     # @param [Integer] desired_row_length of the rows
     # @return [Workbook::Row] a trimmed clone of the array
-    def trim desired_row_length=nil
-      self.clone.trim!(desired_row_length)
+    def trim desired_row_length = nil
+      clone.trim!(desired_row_length)
     end
 
     # remove all the trailing empty-rows (returning a trimmed self)
     #
     # @param [Integer] desired_row_length of the new row
     # @return [Workbook::Row] self
-    def trim! desired_row_length=nil
-      max_length = self.collect{|a| a.trim.length }.max
-      self_count = self.count-1
-      self.count.times do |index|
+    def trim! desired_row_length = nil
+      max_length = collect { |a| a.trim.length }.max
+      self_count = count - 1
+      count.times do |index|
         index = self_count - index
-        if self[index].trim.empty?
-          self.delete_at(index)
+        if @rows[index].trim.empty?
+          delete_at(index)
         else
           break
         end
       end
-      self.each{|a| a.trim!(max_length)}
+      each { |a| a.trim!(max_length) }
       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]
+      height = count
+      width = collect { |a| a.length }.max
+      [width, height]
     end
 
     # Returns an array of Column-classes describing the columns of this table
     # @return [Array<Column>] columns
     def columns
-      @columns ||= header.collect do |header_cell|
+      @columns ||= header.collect { |header_cell|
         Column.new(self)
-      end
+      }
     end
 
     # Returns an array of Column-classes describing the columns of this table
     # @param [Array<Column>] columns
     # @return [Array<Column>] columns
     def columns= columns
-      columns.each{|c| c.table=self}
+      columns.each { |c| c.table = self }
       @columns = columns
     end
-
   end
 end

data/lib/workbook/template.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
-require 'workbook/modules/raw_objects_storage'
+
+require "workbook/modules/raw_objects_storage"
 
 module Workbook
   # Workbook::Template is a container for different Workbook::Format's and the storage of raw template data that isn't really supported by Workbook, but should survive a typical read/write cyclus.
@@ -25,9 +24,9 @@ module Workbook
     def add_format format
       if format.is_a? Workbook::Format
         if format.name
-          @formats[format.name]=format
+          @formats[format.name] = format
         else
-          @formats[@formats.keys.count]=format
+          @formats[@formats.keys.count] = format
         end
       else
         raise ArgumentError, "format should be a Workboot::Format"
@@ -36,31 +35,29 @@ module Workbook
 
     # Return the list of associated formats
     # @return [Hash] A keyed-hash of named formats
-    def formats
-      @formats
-    end
+    attr_reader :formats
 
     # Create or find a format by name
     # @return [Workbook::Format] The new or found format
     # @param [String] name of the format (e.g. whatever you want, in diff names such as 'destroyed', 'updated' and 'created' are being used)
     # @param [Symbol] variant can also be a strftime formatting string (e.g. "%Y-%m-%d")
-    def create_or_find_format_by name, variant=:default
+    def create_or_find_format_by name, variant = :default
       fs = @formats[name]
       fs = @formats[name] = {} if fs.nil?
       f = fs[variant]
       if f.nil?
-        f = Workbook::Format.new
-        if variant != :default and fs[:default]
-          f = fs[:default].clone
+        @formats[name][variant] = if (variant != :default) && fs[:default]
+          fs[:default].clone
+        else
+          Workbook::Format.new
         end
-        @formats[name][variant] = f
       end
-      return @formats[name][variant]
+      @formats[name][variant]
     end
 
     def set_default_formats!
       header_fmt = create_or_find_format_by :header
-      header_fmt[:font_weight] = 'bold'
+      header_fmt[:font_weight] = "bold"
     end
   end
 end

data/lib/workbook/types/false.rb

@@ -1,2 +1 @@
 # frozen_string_literal: true
-

data/lib/workbook/types/nil.rb

@@ -1,2 +1 @@
 # frozen_string_literal: true
-

data/lib/workbook/types/nil_class.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'workbook/cell'
+require "workbook/cell"
 
 module Workbook
   module Types

data/lib/workbook/types/numeric.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'workbook/cell'
+require "workbook/cell"
 
 module Workbook
   module Types

data/lib/workbook/types/string.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'workbook/cell'
+require "workbook/cell"
 
 module Workbook
   module Types

data/lib/workbook/types/time.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'workbook/cell'
+require "workbook/cell"
 
 module Workbook
   module Types

data/lib/workbook/types/true.rb

@@ -1,2 +1 @@
 # frozen_string_literal: true
-

data/lib/workbook/types/true_class.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'workbook/cell'
+require "workbook/cell"
 
 module Workbook
   module Types

data/lib/workbook/version.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
+
 module Workbook
-  VERSION = '0.8.1'
+  VERSION = "0.8.2"
 end

data/lib/workbook/writers/csv_table_writer.rb

@@ -1,8 +1,7 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
-require 'csv'
+
+require "csv"
 
 module Workbook
   module Writers
@@ -11,15 +10,14 @@ module Workbook
       #
       # @param [Hash] options (not used)
       # @return [String] csv (comma separated values in a string)
-      def to_csv options={}
+      def to_csv options = {}
         csv = ""
-        options = {}.merge options
-        self.each_with_index do |r, ri|
-          line=nil
+        @rows.each_with_index do |r, ri|
+          line = nil
           begin
-            line = CSV::generate_line(r.collect{|c| c.value if c},{:row_sep=>""})
+            line = CSV.generate_line(r.cells.collect { |c| c&.value }, row_sep: "")
           rescue TypeError
-            line = CSV::generate_line(r.collect{|c| c.value if c})
+            line = CSV.generate_line(r.cells.collect { |c| c&.value })
           end
           csv += "#{line}\n"
         end
@@ -31,11 +29,10 @@ module Workbook
       # @param [String] filename
       # @param [Hash] options   see #to_csv
       # @return [String] filename
-      def write_to_csv filename="#{title}.csv", options={}
-        File.open(filename, 'w') {|f| f.write(to_csv(options)) }
-        return filename
+      def write_to_csv filename = "untitled document.csv", options = {}
+        File.open(filename, "w") { |f| f.write(to_csv(options)) }
+        filename
       end
-
     end
   end
 end