workbook 0.4.2 → 0.4.3

data/lib/workbook/modules/table_diff_sort.rb

@@ -1,13 +1,13 @@
 # -*- encoding : utf-8 -*-
 module Workbook
-	module Modules
+  module Modules
     # Adds diffing and sorting functions
-		module TableDiffSort
+    module TableDiffSort
       # 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::Book] (note should and will become Workbook::Table as diffing occurs on table level...)
       def diff other, options={:sort=>true,:ignore_headers=>false}
-        
+
         aligned = align(other, options)
         aself = aligned[:self]
         aother = aligned[:other]
@@ -24,7 +24,7 @@ module Workbook
           row = diff_table[ri] = Workbook::Row.new(nil, diff_table)
           srow = aself[ri]
           orow = aother[ri]
-          
+
           iteration_cols.each_with_index do |ch, ci|
             scell = srow[ch]
             ocell = orow[ch]
@@ -45,7 +45,7 @@ module Workbook
               f = diff_template.template.create_or_find_format_by 'updated'
               dcell.format = f
             end
-            
+
             row[ci]=dcell
           end
         end
@@ -55,7 +55,7 @@ module Workbook
 
         diff_table
       end
-      
+
       def diff_template
         return @diff_template if @diff_template
         diffbook = Workbook::Book.new
@@ -74,12 +74,12 @@ module Workbook
         @diff_template = diffbook
         return difftable
       end
-      
+
       # aligns itself with another table, used by diff
       def align other, options={:sort=>true,:ignore_headers=>false}
-        
+
         options = {:sort=>true,:ignore_headers=>false}.merge(options)
-        
+
         iteration_cols = nil
         sother = other.clone.remove_empty_lines!
         sself = self.clone.remove_empty_lines!
@@ -88,20 +88,20 @@ module Workbook
           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
-        
+
         iteration_rows =  [sother.count,sself.count].max.times.collect
 
         row_index = 0
         while row_index < [sother.count,sself.count].max and row_index < other.count+self.count do
           row_index = align_row(sself, sother, row_index)
         end
-        
-        {:self=>sself, :other=>sother}     
+
+        {:self=>sself, :other=>sother}
       end
-      
+
       # for use in the align 'while' loop
       def align_row sself, sother, row_index
         asd = 0
@@ -119,25 +119,25 @@ module Workbook
           sself.insert row_index, placeholder_row
           row_index -=1
         end
-        
+
         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?)
       end
-      
+
       # returns a placeholder row, for internal use only
-      def placeholder_row 
+      def placeholder_row
         if @placeholder_row != nil
-          return @placeholder_row 
+          return @placeholder_row
         else
           @placeholder_row = Workbook::Row.new [nil]
           placeholder_row.placeholder = true
-          return @placeholder_row 
+          return @placeholder_row
         end
       end
-	  end
-	end
+    end
+  end
 end

data/lib/workbook/modules/type_parser.rb

@@ -3,19 +3,19 @@ module Workbook
   module Modules
     # Adds type parsing capabilities to e.g. a Cell.
     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")
       end
-      
+
       # Return the different active string parsers
       # @return [Array<Symbol>] A list of parsers
       def string_parsers
         @string_parsers ||= [:string_cleaner,:string_nil_converter,:string_integer_converter,:string_boolean_converter]
       end
-      
+
       # Set the list of string parsers
       # @param [Array<Symbol>] parsers A list of parsers
       # @return [Array<Symbol>] A list of parsers
@@ -24,11 +24,11 @@ module Workbook
       end
 
       # Return the different active string parsers
-      # @return [Array<Proc>] A list of parsers as Procs   
+      # @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)}
       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={}
@@ -40,30 +40,30 @@ module Workbook
             v = p.call(v)
           end
         end
-        v  
+        v
       end
-      
+
       def parse! options={}
         self.value = parse(options)
       end
-      
+
       def clean! options={}
         parse! options
       end
-      
+
       def string_cleaner
         proc do |v|
-          v = v.strip 
+          v = v.strip
           v.gsub('mailto:','')
         end
       end
-      
+
       def string_nil_converter
         proc do |v|
           (v == "" ? nil : v)
         end
       end
-      
+
       def string_integer_converter
         proc do |v|
           if v.to_i.to_s == v
@@ -73,19 +73,19 @@ module Workbook
           end
         end
       end
-      
+
       def string_optimistic_date_converter
-        proc do |v|  
+        proc do |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
-          
+
           normal_date_length = v.to_s.length <= 25
           if no_spaced_dash and starts_with_nr and normal_date_length and 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
@@ -100,13 +100,13 @@ module Workbook
               rescue ArgumentError
               end
             end
-          end          
+          end
           rv
         end
       end
 
       # converts 'true' or 'false' strings in `true` or `false` values
-      # return [Proc] that returns a boolean value if it is considered as such 
+      # return [Proc] that returns a boolean value if it is considered as such
       def string_boolean_converter
         proc do |v|
           dv = v.downcase

data/lib/workbook/nil_value.rb

@@ -1,25 +1,25 @@
 module Workbook
-  
+
   # Used in cases col or rowspans are used
   class NilValue
     attr_accessor :reason #:covered
-    
+
     # initialize this special nilvalue with a reason
     # @params [String] reason (currently only :covered, in case this cell is coverd because an adjecant cell spans over it)
     def initialize reason
       self.reason= reason
     end
-    
+
     # returns the value of itself (nil)
     # @return [NilClass] nil
     def value
       nil
     end
-    
+
     def <=> v
       value <=> v
     end
-    
+
     # set the reason why this value is nil
     def reason= reason
       if reason == :covered
@@ -28,6 +28,6 @@ module Workbook
         raise "invalid reason given"
       end
     end
-    
+
   end
 end

data/lib/workbook/readers/csv_reader.rb

@@ -7,7 +7,7 @@ module Workbook
         csv = text
         parse_csv csv
       end
-      
+
       def csv_lib
         if RUBY_VERSION < '1.9'
           require 'faster_csv'
@@ -16,7 +16,7 @@ module Workbook
           return CSV
         end
       end
-      
+
       def parse_csv csv_raw
         custom_date_converter = Workbook::Cell.new.string_optimistic_date_converter
         converters = [:float,:integer,:date,:date_time,custom_date_converter]
@@ -24,18 +24,18 @@ module Workbook
         #begin
         csv = csv_lib.parse(csv_raw,{:converters=>converters})
 
-          #rescue
-          # we're going to have another shot at it...
-          #end
-        
-        if csv==nil or csv[0].count == 1 
+        #rescue
+        # we're going to have another shot at it...
+        #end
+
+        if csv==nil or csv[0].count == 1
           csv_excel = csv_lib.parse(csv_raw,{:converters=>converters,: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

data/lib/workbook/readers/ods_reader.rb

@@ -12,9 +12,9 @@ module Workbook
         styles = ""
         Zip::ZipFile.open(file_obj) do |zipfile|
           zipfile.entries.each do |file|
-            styles = zipfile.read(file.name) if file.name == "styles.xml"  
-            
-            content = zipfile.read(file.name) if file.name == "content.xml"  
+            styles = zipfile.read(file.name) if file.name == "styles.xml"
+
+            content = zipfile.read(file.name) if file.name == "content.xml"
           end
         end
         content = Nokogiri.XML(content)
@@ -24,12 +24,12 @@ module Workbook
         parse_ods content
         return self
       end
-      
+
       def set_format_property format, property, value
         value.strip!
         format[property] = value if value and value != ""
       end
-      
+
       def parse_ods_style parse_ods_style
         parse_ods_style.xpath("//style:style").each do |style|
           style_family = style.xpath("@style:family").to_s
@@ -47,63 +47,109 @@ module Workbook
           end
         end
       end
-      
+
       # updates self with and ods-type content.xml
       # @param [Nokogiri::XML::Document] ods_spreadsheet nokogirified content.xml
       # @return [Workbook::Book] self
       def parse_ods ods_spreadsheet=template.raws[Nokogiri::XML::Document], options={}
         require 'cgi'
-        
+
         options = {:additional_type_parsing=>false}.merge options
         # styles
         #puts ods_spreadsheet
         parse_ods_style ods_spreadsheet
-        
+
         # data
         ods_spreadsheet.xpath("//office:body/office:spreadsheet").each_with_index do |sheet,sheetindex|
-          s = self.create_or_open_sheet_at(sheetindex)
+          workbook_sheet = self.create_or_open_sheet_at(sheetindex)
           sheet.xpath("table:table").each_with_index do |table,tableindex|
-            t = s.create_or_open_table_at(tableindex)
-            t.name = table.xpath("@table:name").to_s
-            columns = table.xpath("table:table-column").count
-            table.xpath("table:table-row").each_with_index do |row,rowindex|
-              cells = row.xpath("table:table-cell|table:covered-table-cell")
-              r = Workbook::Row.new
-              columns.times do |column_index|
-                cell = cells[column_index]
-                c = Workbook::Cell.new()
-                value = nil
-                if cell
-                  if cell.name == "covered-table-cell"
-                    value = Workbook::NilValue.new(:covered)
-                  else
-                    cell_style_name = cell.xpath('@table:style-name').to_s
-                    c.format = self.template.formats[cell_style_name]
-                    valuetype = cell.xpath('@office:value-type').to_s
-                    c.colspan= cell.xpath('@table:number-columns-spanned').to_s
-                    c.rowspan= cell.xpath('@table:number-rows-spanned').to_s
-
-                    value = CGI.unescapeHTML(cell.xpath("text:p//text()").to_s)
-                    value = (value == "") ? nil : value
-                    case valuetype
-                    when 'float'
-                      value = cell.xpath("@office:value").to_s.to_f
-                    when 'integer'
-                      value = cell.xpath("@office:value").to_s.to_i
-                    when 'date'
-                      value = DateTime.parse(cell.xpath("@office:date-value").to_s)
-                    end    
-                  end
-                end
-                c.value = value
-                r << c
-              end
-              t << r
-            end
+            parse_local_table(workbook_sheet,table,tableindex)
           end
         end
         return self
       end
+
+      #parse the contents of an entire table by parsing every row in it and adding it to the table
+      def parse_local_table(sheet,table,tableindex)
+        local_table = sheet.create_or_open_table_at(tableindex)
+        local_table.name = table.xpath("@table:name").to_s
+        #column_count = get_column_count(table)
+        table.xpath("table:table-row").each do |row|
+          local_table << parse_local_row(row)
+        end
+        local_table.trim!
+      end
+
+      #set column count
+      def get_column_count(table)
+        init_column_count = table.xpath("table:table-column").count
+        first_row = table.xpath("table:table-row").first
+        cells = first_row.xpath("table:table-cell|table:covered-table-cell")
+        column_count = 0
+        cells.each do |cell|
+          if cell.xpath('@table:number-columns-spanned').children.size>0
+            column_count +=cell.xpath('@table:number-columns-spanned').children[0].inner_text.to_i
+          else
+            column_count +=1
+          end
+        end
+        column_count
+      end
+
+      #parse the contents of an entire row by parsing every cell in it and adding it to the row
+      def parse_local_row(row)
+        cells = row.xpath("table:table-cell|table:covered-table-cell")
+        workbook_row = Workbook::Row.new
+        cells.each do |cell|
+          @cell = cell
+          repeat = get_repeat
+          workbook_cell = Workbook::Cell.new()
+          workbook_cell.value = @cell.nil? ? nil : parse_local_cell(workbook_cell)
+          repeat.times do
+            workbook_row << workbook_cell
+          end
+        end
+        return workbook_row
+      end
+
+      def get_repeat
+        pre_set = @cell.xpath('@table:number-columns-repeated').to_s
+        return 1 if (pre_set.nil? || pre_set=="") # if not present, don't repeat.
+        return 1 unless "#{pre_set.to_i}"=="#{pre_set}" # return 1 if it's not a valid integer
+        return 1 if pre_set.to_i < 1 # return 1, negative repeats make no sense
+        return pre_set.to_i
+      end
+
+      #parse the contents of a single cell
+      def parse_local_cell(workbook_cell)
+        return Workbook::NilValue.new(:covered) if @cell.name == "covered-table-cell"
+        set_cell_attributes(workbook_cell)
+        valuetype = @cell.xpath('@office:value-type').to_s
+        parse_local_value(valuetype)
+      end
+
+      # Sets cell attributes for rowspan, colspan and format
+      def set_cell_attributes(workbook_cell)
+        workbook_cell.format = self.template.formats[@cell.xpath('@table:style-name').to_s]
+        workbook_cell.colspan= @cell.xpath('@table:number-columns-spanned').to_s
+        workbook_cell.rowspan= @cell.xpath('@table:number-rows-spanned').to_s
+      end
+
+      # Sets value in right context type
+      def parse_local_value(valuetype)
+        value = CGI.unescapeHTML(@cell.xpath("text:p//text()").to_s)
+        value = (value=="") ? nil : value
+        case valuetype
+        when 'float'
+          value = @cell.xpath("@office:value").to_s.to_f
+        when 'integer'
+          value = @cell.xpath("@office:value").to_s.to_i
+        when 'date'
+          value = DateTime.parse(@cell.xpath("@office:date-value").to_s)
+        end
+        value
+      end
+
     end
   end
 end