workbook 0.8.1 → 0.9.0

data/lib/workbook/modules/diff_sort.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
+
 module Workbook
   module Modules
     # Adds essential diffing and comparing support, as well as diffing entire books
@@ -11,21 +10,22 @@ module Workbook
         #
         # @return [Workbook::Table] the empty table, linked to a book
         def new_diff_template
-            diffbook = Workbook::Book.new
-            template = diffbook.template
-            f = template.create_or_find_format_by 'destroyed'
-            f[:background_color]=:red
-            f = template.create_or_find_format_by 'updated'
-            f[:background_color]=:yellow
-            f = template.create_or_find_format_by 'created'
-            f[:background_color]=:lime
-            f = template.create_or_find_format_by 'header'
-            f[:rotation] = 72
-            f[:font_weight] = :bold
-            f[:height] = 80
-            diffbook
+          diffbook = Workbook::Book.new
+          template = diffbook.template
+          f = template.create_or_find_format_by "destroyed"
+          f[:background_color] = :red
+          f = template.create_or_find_format_by "updated"
+          f[:background_color] = :yellow
+          f = template.create_or_find_format_by "created"
+          f[:background_color] = :lime
+          f = template.create_or_find_format_by "header"
+          f[:rotation] = 72
+          f[:font_weight] = :bold
+          f[:height] = 80
+          diffbook
         end
       end
+
       def self.included(base)
         base.extend(ClassMethods)
       end
@@ -34,9 +34,9 @@ module Workbook
       #
       # @param [Workbook::Book] to_workbook to compare against
       # @return [Workbook::Book] workbook with compared result
-      def diff to_workbook, options={:sort=>true,:ignore_headers=>false}
+      def diff to_workbook, options = {sort: true, ignore_headers: false}
         diff_template = Workbook::Book.new_diff_template
-        self.each_with_index do |from_sheet, sheet_index|
+        each_with_index do |from_sheet, sheet_index|
           to_sheet = to_workbook[sheet_index]
           if to_sheet
             from_table = from_sheet.table
@@ -46,7 +46,7 @@ module Workbook
             from_table.diff(to_table, options)
           end
         end
-        return diff_template #the template has been filled in the meanwhile, not to use as a template anymore... :)
+        diff_template # the template has been filled in the meanwhile, not to use as a template anymore... :)
       end
     end
 
@@ -55,27 +55,27 @@ module Workbook
       # create an overview of the differences between itself with another 'previous' table, returns a book with a single sheet and table (containing the diffs)
       #
       # @return [Workbook::Table] the return result
-      def diff other, options={}
-        options = {:sort=>true,:ignore_headers=>false}.merge(options)
+      def diff other, options = {}
+        options = {sort: true, ignore_headers: false}.merge(options)
 
         aligned = align(other, options)
         aself = aligned[:self]
         aother = aligned[:other]
 
         iteration_cols = []
-        if options[:ignore_headers]
-          iteration_cols = [aother.first.count,aself.first.count].max.times.collect
+        iteration_cols = if options[:ignore_headers]
+          [aother.first.count, aself.first.count].max.times.collect
         else
-          iteration_cols = (aother.header.to_symbols+aother.header.to_symbols).uniq
+          (aother.header.to_symbols + aother.header.to_symbols).uniq
         end
 
         diff_table = diff_template
-        maxri = (aself.count-1)
+        maxri = (aself.count - 1)
 
-        for ri in 0..maxri do
-          row = diff_table[ri] = Workbook::Row.new(nil, diff_table)
-          srow = aself[ri]
-          orow = aother[ri]
+        (0..maxri).each do |ri|
+          row = diff_table.rows[ri] = Workbook::Row.new(nil, diff_table)
+          srow = aself.rows[ri]
+          orow = aother.rows[ri]
 
           iteration_cols.each_with_index do |ch, ci|
             scell = srow[ch]
@@ -83,38 +83,13 @@ module Workbook
             row[ci] = create_diff_cell(scell, ocell)
           end
         end
-        if !options[:ignore_headers]
-          diff_table[0].format = diff_template.template.create_or_find_format_by 'header'
+        unless options[:ignore_headers]
+          diff_table[0].format = diff_template.template.create_or_find_format_by "header"
         end
 
         diff_table
       end
 
-      # creates a new cell describing the difference between two cells
-      #
-      # @return [Workbook::Cell] the diff cell
-      def create_diff_cell(scell, ocell)
-        dcell = scell.nil? ? Workbook::Cell.new(nil) : scell
-        if (scell == ocell)
-          dcell.format = scell.format if scell
-        elsif scell.nil?
-          dcell = Workbook::Cell.new "(was: #{ocell.to_s})"
-          dcell.format = diff_template.template.create_or_find_format_by 'destroyed'
-        elsif ocell.nil?
-          dcell = scell.clone
-          fmt = scell.nil? ? :default : scell.format[:number_format]
-          f = diff_template.template.create_or_find_format_by 'created', fmt
-          f[:number_format] = scell.format[:number_format]
-          dcell.format = f
-        elsif scell != ocell
-          dcell = Workbook::Cell.new "#{scell.to_s} (was: #{ocell.to_s})"
-          f = diff_template.template.create_or_find_format_by 'updated'
-          dcell.format = f
-        end
-
-        dcell
-      end
-
       # Return template table to write the diff result in; in case non exists a default is generated.
       #
       # @return [Workbook::Table] the empty table, linked to a book
@@ -131,71 +106,105 @@ module Workbook
       # @param [Workbook::Table] table to diff inside
       # @return [Workbook::Table] the passed table
       def diff_template= table
-        @diff_template= table
+        @diff_template = table
       end
 
       # aligns itself with another table, used by diff
       #
       # @param [Workbook::Table] other table to align with
       # @param [Hash] options default to: `{:sort=>true,:ignore_headers=>false}`
-      def align other, options={:sort=>true,:ignore_headers=>false}
-
-        options = {:sort=>true,:ignore_headers=>false}.merge(options)
+      def align other, options = {}
+        options = {sort: true, ignore_headers: false}.merge(options)
 
         sother = other.clone.remove_empty_lines!
-        sself = self.clone.remove_empty_lines!
+        sself = clone.remove_empty_lines!
 
         if options[:ignore_headers]
           sother.header = false
           sself.header = false
         end
 
-        sother = options[:sort] ? Workbook::Table.new(sother.sort) : sother
-        sself = options[:sort] ? Workbook::Table.new(sself.sort) : sself
+        sother = options[:sort] ? sother.sort : sother
+        sself = options[:sort] ? sself.sort : sself
 
         row_index = 0
-        while row_index < [sother.count,sself.count].max and row_index < other.count+self.count do
+        while (row_index < [sother.count, sself.count].max) && (row_index < other.count + count)
           row_index = align_row(sself, sother, row_index)
         end
 
-        {:self=>sself, :other=>sother}
+        {self: sself, other: sother}
       end
 
+      def sort
+        clone.sort!
+      end
+
+      def sort!
+        header_row = @rows.delete_at(header_row_index) if header
+        @rows = [header_row] + @rows.sort
+        self
+      end
+
+      private
+
       # for use in the align 'while' loop
       def align_row sself, sother, row_index
         asd = 0
-        if sself[row_index] and sother[row_index]
-          asd = sself[row_index].key <=> sother[row_index].key
-        elsif sself[row_index]
+        if sself.rows[row_index] && sother.rows[row_index]
+          asd = sself.rows[row_index].key <=> sother.rows[row_index].key
+        elsif sself.rows[row_index]
           asd = -1
-        elsif sother[row_index]
+        elsif sother.rows[row_index]
           asd = 1
         end
-        if asd == -1 and insert_placeholder?(sother, sself, row_index)
-          sother.insert row_index, placeholder_row
-          row_index -=1
-        elsif asd == 1 and insert_placeholder?(sother, sself, row_index)
-          sself.insert row_index, placeholder_row
-          row_index -=1
+        if (asd == -1) && insert_placeholder?(sother, sself, row_index)
+          sother.rows.insert row_index, placeholder_row
+          row_index -= 2
+        elsif (asd == 1) && insert_placeholder?(sother, sself, row_index)
+          sself.rows.insert row_index, placeholder_row
+          row_index -= 2
         end
 
-        row_index += 1
+        row_index + 1
       end
 
       def insert_placeholder? sother, sself, row_index
-        (sother[row_index].nil? or !sother[row_index].placeholder?) and
-        (sself[row_index].nil? or !sself[row_index].placeholder?)
+        (sother.rows[row_index].nil? || !sother.rows[row_index].placeholder?) &&
+          (sself.rows[row_index].nil? || !sself.rows[row_index].placeholder?)
       end
 
       # returns a placeholder row, for internal use only
       def placeholder_row
-        if defined?(@placeholder_row) and !@placeholder_row.nil?
-          return @placeholder_row
-        else
-          @placeholder_row = Workbook::Row.new [nil]
-          placeholder_row.placeholder = true
-          return @placeholder_row
+        return @placeholder_row if defined?(@placeholder_row) && !@placeholder_row.nil?
+
+        @placeholder_row = Workbook::Row.new [nil]
+        @placeholder_row.placeholder = true
+        @placeholder_row
+      end
+
+      # creates a new cell describing the difference between two cells
+      #
+      # @return [Workbook::Cell] the diff cell
+      def create_diff_cell(scell, ocell)
+        dcell = scell.nil? ? Workbook::Cell.new(nil) : scell
+        if scell == ocell
+          dcell.format = scell.format if scell
+        elsif scell.nil?
+          dcell = Workbook::Cell.new "(was: #{ocell})"
+          dcell.format = diff_template.template.create_or_find_format_by "destroyed"
+        elsif ocell.nil?
+          dcell = scell.clone
+          fmt = scell.nil? ? :default : scell.format[:number_format]
+          f = diff_template.template.create_or_find_format_by "created", fmt
+          f[:number_format] = scell.format[:number_format]
+          dcell.format = f
+        elsif scell != ocell
+          dcell = Workbook::Cell.new "#{scell} (was: #{ocell})"
+          f = diff_template.template.create_or_find_format_by "updated"
+          dcell.format = f
         end
+
+        dcell
       end
     end
   end

data/lib/workbook/modules/raw_objects_storage.rb

@@ -1,16 +1,14 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
+
 module Workbook
   module Modules
     # Adds support for storing raw objects, used in e.g. Format and Template
     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, options={}
-        class_of_obj = options[:raw_object_class] ? options[:raw_object_class] : raw_object.class
-        raws[class_of_obj]=raw_object
+      def add_raw raw_object, options = {}
+        class_of_obj = 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
@@ -21,8 +19,8 @@ module Workbook
       # Returns raw data stored for a type of raw object (if available)
       # @param [Class] raw_object_class (e.g. Spreadsheet::Format for the Spreadsheet-gem)
       def return_raw_for raw_object_class
-        raws.each { |tc,t| return t if tc == raw_object_class}
-        return nil
+        raws.each { |tc, t| return t if tc == raw_object_class }
+        nil
       end
 
       # Remove all raw data references

data/lib/workbook/modules/type_parser.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
-
-# -*- encoding : utf-8 -*-
 # frozen_string_literal: true
+
 module Workbook
   module Modules
     # Adds type parsing capabilities to e.g. a Cell.
+    #
+    # Cell#string_parsers can be appended with symbols referencing the
     module TypeParser
-
       # Cleans a text file from all kinds of different ways of representing new lines
       # @param [String] csv_raw a raw csv string
       def strip_win_chars csv_raw
-        csv_raw.gsub(/(\n\r|\r\n|\r)/,"\n")
+        csv_raw.gsub(/(\n\r|\r\n|\r)/, "\n")
       end
 
       # Return the different active string parsers
-      # @return [Array<Symbol>] A list of parsers
+      # @return [Array<Symbol>] A list of parsers, defaults to [:string_cleaner, :string_integer_converter, :string_boolean_converter]
       def string_parsers
-        @string_parsers ||= [:string_cleaner,:string_integer_converter,:string_boolean_converter]
+        @string_parsers ||= [:string_cleaner, :string_integer_converter, :string_boolean_converter]
       end
 
       # Set the list of string parsers
@@ -29,15 +29,17 @@ module Workbook
       # Return the different active string parsers
       # @return [Array<Proc>] A list of parsers as Procs
       def string_parsers_as_procs
-        string_parsers.collect{|c| c.is_a?(Proc) ? c : self.send(c)}
+        string_parsers.collect { |c| c.is_a?(Proc) ? c : send(c) }
       end
 
       # Returns the parsed value (retrieved by calling #value)
       # @return [Object] The parsed object, ideally a date or integer when found to be a such...
-      def parse options={}
-        options = {:detect_date=>false, :convert_empty_to_nil=>true}.merge(options)
+      def parse options = {}
+        options = {detect_date: false, convert_empty_to_nil: true}.merge(options)
+
         string_parsers.push :string_optimistic_date_converter if options[:detect_date]
         string_parsers.push :string_nil_converter if options[:convert_empty_to_nil]
+
         v = value
         string_parsers_as_procs.each do |p|
           if v.is_a? String
@@ -47,27 +49,30 @@ module Workbook
         v
       end
 
-      def parse! options={}
+      def parse! options = {}
         self.value = parse(options)
       end
 
-      def clean! options={}
+      def clean! options = {}
         parse! options
       end
 
+      # @return [Proc] that does some cleaning in strings
       def string_cleaner
         proc do |v|
           v = v.strip
-          v.gsub('mailto:','')
+          v.gsub("mailto:", "")
         end
       end
 
+      # @return [Proc] that returns nil for an empty string
       def string_nil_converter
         proc do |v|
           (v == "" ? nil : v)
         end
       end
 
+      # @return [Proc] that tries to distill an integer
       def string_integer_converter
         proc do |v|
           if v.to_i.to_s == v
@@ -78,19 +83,20 @@ module Workbook
         end
       end
 
+      # @return [Proc] that tries to distill a date from a string
       def string_optimistic_date_converter
         proc do |v|
           if v
             rv = v
-            starts_with_nr = v.chars.first.to_i.to_s == v.chars.first #it should at least start with a number...
-            no_spaced_dash = v.to_s.match(" - ") ? false : true
-            min_two_dashes = v.to_s.scan("-").count > 1 ? true : false
-            min_two_dashes = v.to_s.scan("/").count > 1 ? true : false if min_two_dashes == false
+            starts_with_nr = v[0].to_i.to_s == v[0] # it should at least start with a number...
+            no_spaced_dash = !v.to_s.match?(" - ")
+            min_two_dashes = v.to_s.scan("-").count > 1
+            min_two_dashes = v.to_s.scan("/").count > 1 if min_two_dashes == false
 
             normal_date_length = v.to_s.length <= 25
-            if no_spaced_dash and starts_with_nr and normal_date_length and min_two_dashes
+            if no_spaced_dash && starts_with_nr && normal_date_length && min_two_dashes
               begin
-                rv = (v.length > 10) ? DateTime.parse(v) : Date.parse(v)
+                rv = v.length > 10 ? DateTime.parse(v) : Date.parse(v)
               rescue ArgumentError
                 rv = v
               end
@@ -104,14 +110,15 @@ module Workbook
         end
       end
 
+      # @return [Proc] that tries to distill a date from a string
       def string_american_date_converter
         proc do |v|
           if v
             rv = v
             # try strptime with format 'mm/dd/yyyy'
-            if rv.is_a?(String) && /^\d{1,2}[\/-]\d{1,2}[\/-]\d{4}/ =~ v
+            if rv.is_a?(String) && /^\d{1,2}[\/-]\d{1,2}[\/-]\d{4}$/ =~ v
               begin
-                rv = Date.strptime(v, "%m/%d/%Y")
+                rv = Date.strptime(v.tr("-", "/"), "%m/%d/%Y")
               rescue ArgumentError
               end
             end
@@ -120,13 +127,14 @@ module Workbook
         end
       end
 
+      # @return [Proc] that tries to distill a date from a string
       def string_non_american_date_converter
         proc do |v|
           rv = v
           # try strptime with format 'mm/dd/yyyy'
-          if rv.is_a?(String) && /^\d{1,2}[\/\-\.]\d{1,2}[\/\-\.]\d{4}/ =~ v
+          if rv.is_a?(String) && /^\d{1,2}[\/\-.]\d{1,2}[\/\-.]\d{4}$/ =~ v
             begin
-              rv = Date.strptime(v, "%m/%d/%Y")
+              rv = Date.strptime(v.gsub(/[-.]/, "/"), "%d/%m/%Y")
             rescue ArgumentError
             end
           end

data/lib/workbook/nil_value.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
 module Workbook
-
   # Used in cases col or rowspans are used
   class NilValue
-
     # initialize this special nilvalue with a reason
     # @param [String] reason (currently only :covered, in case this cell is coverd because an adjecant cell spans over it)
     def initialize reason
-      self.reason= reason
+      self.reason = reason
     end
 
     # returns the value of itself (nil)
@@ -17,13 +15,11 @@ module Workbook
       nil
     end
 
-    def <=> v
-      value <=> v
+    def <=> other
+      value <=> other
     end
 
-    def reason
-      @reason
-    end
+    attr_reader :reason
 
     # set the reason why this value is nil
     def reason= reason
@@ -33,6 +29,5 @@ module Workbook
         raise "invalid reason given"
       end
     end
-
   end
 end

data/lib/workbook/readers/csv_reader.rb

@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 
-# -*- encoding : utf-8 -*-
-
 module Workbook
   module Readers
     module CsvReader
-      def load_csv text, options={}
+      def load_csv text, options = {}
         csv = text
         parse_csv csv, options
       end
 
       def csv_lib
-        return CSV
+        CSV
       end
 
-      def parse_csv csv_raw, options={}
+      def parse_csv csv_raw, options = {}
         optimistic_date_converter = Workbook::Cell.new.string_optimistic_date_converter
         options = {
           converters: [optimistic_date_converter, :all]
@@ -23,20 +21,19 @@ module Workbook
         csv = nil
 
         begin
-          csv = CSV.parse(csv_raw, options)
+          csv = CSV.parse(csv_raw, **options)
         rescue CSV::MalformedCSVError
-          csv_excel = CSV.parse(csv_raw,options.merge({:col_sep=>';'}))
+          csv_excel = CSV.parse(csv_raw, **options.merge({col_sep: ";"}))
           csv = csv_excel if csv_excel[0].count > 1
         end
 
-        if csv==nil or csv[0].count == 1
-          csv_excel = CSV.parse(csv_raw,options.merge({:col_sep=>';'}))
+        if csv.nil? || (csv[0].count == 1)
+          csv_excel = CSV.parse(csv_raw, **options.merge({col_sep: ";"}))
           csv = csv_excel if csv_excel[0].count > 1
         end
 
         self[0] = Workbook::Sheet.new(csv, self) unless sheet.has_contents?
       end
-
     end
   end
 end