workbook 0.1.1

data/.gitignore

@@ -0,0 +1,4 @@
+untitled document.xls
+test.xls
+compare*.xls
+sharepoint_download_excel.*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in workbook.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,22 @@
+PATH
+  remote: .
+  specs:
+    workbook (0.1.0)
+      fastercsv
+      rchardet (~> 1.3)
+      spreadsheet (>= 0.6.8)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    fastercsv (1.5.4)
+    rchardet (1.3)
+    ruby-ole (1.2.11.3)
+    spreadsheet (0.6.8)
+      ruby-ole (>= 1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  workbook!

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb','test/writers/test*.rb']
+  t.verbose = false
+end

data/lib/workbook/book.rb

@@ -0,0 +1,122 @@
+require 'workbook/writers/xls_writer'
+require 'workbook/readers/xls_reader'
+require 'workbook/readers/csv_reader'
+require 'workbook/readers/txt_reader'
+require 'rchardet'
+
+module Workbook
+  class Book < Array
+    include Workbook::Writers::XlsWriter
+    include Workbook::Readers::XlsReader
+    include Workbook::Readers::CsvReader
+    include Workbook::Readers::TxtReader    
+    
+    attr_accessor :title
+    attr_accessor :template
+    attr_accessor :default_rewrite_header
+    
+    # @param [Workbook::Sheet, Array] Create a new workbook based on an existing sheet, or initialize a sheet based on the array
+    # @return [Workbook::Book]  
+    def initialize sheet=Workbook::Sheet.new([], self, options={})
+      if sheet.is_a? Workbook::Sheet
+        push sheet
+      else
+        push Workbook::Sheet.new(sheet, self, options)
+      end
+    end
+    
+    # @return [Workbook::Format] returns the template describing how the document should be/is formatted
+    def template
+      @template ||= Workbook::Template.new
+    end
+    
+    # @param [Workbook::Format] a template describing how the document should be/is formatted
+    def template= template
+      raise ArgumentError, "format should be a Workboot::Format" unless template.is_a? Workbook::Template
+      @template = template
+    end
+    
+    # @return [String] the title of the workbook
+    def title
+      @title ? @title : "untitled document"
+    end
+    
+  	def push sheet=Workbook::Sheet.new
+      super(sheet)
+    end
+    
+    # @return [Workbook::Sheet] The first sheet, and creates an empty one if one doesn't exists
+    def sheet
+      push Workbook::Sheet.new unless first
+      first
+    end
+    
+    def has_contents?
+      sheet.has_contents?
+    end
+    
+    # Loads an external file into an existing worbook
+    # @param [String] a string with a reference to the file to be opened
+    # @param [String] an optional string enforcing a certain parser (based on the file extension, e.g. 'txt', 'csv' or 'xls')
+    def open filename, ext=nil
+      ext = file_extension(filename) unless ext
+      if ['txt','csv','xml'].include?(ext)
+        open_text filename, ext
+      else
+        open_binary filename, ext
+      end
+    end
+    
+    # Open the file in binary, read-only mode, do not read it, but pas it throug to the extension determined loaded
+    # @param [String] a string with a reference to the file to be opened
+    # @param [String] an optional string enforcing a certain parser (based on the file extension, e.g. 'txt', 'csv' or 'xls')
+    def open_binary filename, ext=nil
+      ext = file_extension(filename) unless ext
+      f = File.open(filename,'rb')
+      send("load_#{ext}".to_sym,f)
+    end
+    
+    # Open the file in non-binary, read-only mode, read it and parse it to UTF-8
+    # @param [String] a string with a reference to the file to be opened
+    # @param [String] an optional string enforcing a certain parser (based on the file extension, e.g. 'txt', 'csv' or 'xls')
+    def open_text filename, ext=nil
+      ext = file_extension(filename) unless ext
+      f = File.open(filename,'r')
+      t = f.read
+      detected_encoding = CharDet.detect(t)['encoding']
+      t = Iconv.conv("UTF-8//TRANSLIT//IGNORE",detected_encoding,t)
+      send("load_#{ext}".to_sym,t)
+    end
+    
+    # @param [String] The full filename, or path
+    # @return [String] The file extension
+    def file_extension(filename)
+      File.extname(filename).gsub('.','').downcase if filename
+    end
+    
+    # Create an instance from a file, using open.
+    # @return [Workbook::Book] A new instance, based on the filename
+    def self.open filename, ext=nil
+      wb = self.new
+      wb.open filename, ext
+      return wb
+    end
+
+    def create_or_open_sheet_at index
+      s = self[index]
+      s = self[index] = Workbook::Sheet.new if s == nil
+      s.book = self
+      s 
+    end
+    
+    def sort
+      raise Exception("Books can't be sorted")
+    end
+    
+    def default_rewrite_header?
+      return true if default_rewrite_header.nil?
+      default_rewrite_header
+    end
+    
+  end
+end

data/lib/workbook/cell.rb

@@ -0,0 +1,143 @@
+# encoding: utf-8
+
+require 'workbook/modules/type_parser'
+
+module Workbook
+  class Cell
+    include Workbook::Modules::TypeParser
+    
+    attr_accessor :value
+    attr_accessor :format
+    attr_accessor :formula
+    
+    # Note that these types are sorted by 'importance'
+    VALID_TYPES = [Numeric,String,Time,Date,TrueClass,FalseClass,NilClass]
+    
+    def valid_value? value
+      valid_type = false 
+      VALID_TYPES.each {|t| return true if value.is_a? t} 
+      valid_type
+    end
+    
+    def initialize value=nil, options={}
+      if valid_value? value
+        format = options[:format] 
+        @value = value
+      else
+        raise ArgumentError, "value should be of a primitive type, e.g. a string, or an integer, not a #{value.class} (is_a? [TrueClass,FalseClass,Date,Time,Numeric,String, NilClass])"
+      end
+    end
+    
+    def format= f
+      if f.is_a? Workbook::Format
+        @format = f
+      elsif f.is_a? Hash
+        @format = Workbook::Format.new(f)
+      elsif f.class == NilClass
+        @format = Workbook::Format.new
+      end
+    end
+    
+    def format
+      @format ||= Workbook::Format.new
+    end
+
+    def ==(other)
+      if other.is_a? Cell
+        other.value == self.value
+      else
+        other == self.value
+      end
+    end
+    
+    def nil?
+      return value.nil?
+    end
+    
+    def to_sym
+      #mb_chars.normalize(:kd).
+      v = nil
+      if value
+        v = value.to_s.downcase
+        v = v.gsub(' (j/?/leeg)','').gsub(/dd-mm-(.*)/,'').gsub(/\ja\/nee/,'').gsub(/\(\)/,'').gsub(/[\(\)]+/, '')
+        v = v.strip.gsub(/(\.|\?|,|\=)/,'').
+            gsub('$','').
+            gsub(/\&/,'en').
+            gsub(/\+/,'_plus_').
+            gsub(/\s/, "_").
+            gsub('–_','').
+            gsub('-_','').
+            gsub('+_','').
+            gsub('/_','_').
+            gsub('/','_').
+            gsub('__','_').
+            gsub('-','')
+            
+        accents = { 
+          ['á','à','â','ä','ã'] => 'a',
+          ['Ã','Ä','Â','À','�?'] => 'A',
+          ['é','è','ê','ë'] => 'e',
+          ['Ë','É','È','Ê'] => 'E',
+          ['í','ì','î','ï'] => 'i',
+          ['�?','Î','Ì','�?'] => 'I',
+          ['ó','ò','ô','ö','õ'] => 'o',
+          ['Õ','Ö','Ô','Ò','Ó'] => 'O',
+          ['ú','ù','û','ü'] => 'u',
+          ['Ú','Û','Ù','Ü'] => 'U',
+          ['ç'] => 'c', ['Ç'] => 'C',
+          ['ñ'] => 'n', ['Ñ'] => 'N'
+        }
+        accents.each do |ac,rep|
+          ac.each do |s|
+            v = v.gsub(s, rep)
+          end
+        end
+        
+        v = v.gsub(/[^\x00-\x7F]/n,'').downcase.to_sym
+      end
+      v
+    end
+    
+    def <=> other
+      rv = nil
+      begin
+        rv = self.value <=> other.value
+      rescue NoMethodError => e
+        rv = compare_on_class other
+      end
+      if rv == nil        
+        rv = compare_on_class other
+      end
+      return rv
+
+    end
+    
+    def compare_on_class other
+      other_value = nil
+      other_value = other.value if other
+      self_value = importance_of_class self.value
+      other_value = importance_of_class other_value
+      self_value <=> other_value
+    end
+    
+    def importance_of_class value
+      VALID_TYPES.each_with_index do |c,i|  
+        return i if value.is_a? c
+      end
+      return nil
+    end
+    
+    def inspect
+      "<Workbook::Cell @value=#{value}>"
+    end
+    
+    def to_s
+      if (value.is_a? Date or value.is_a? Time) and format[:number_format]
+        value.strftime(format[:number_format])
+      else
+        value.to_s
+      end
+    end
+    
+  end
+end

data/lib/workbook/format.rb

@@ -0,0 +1,35 @@
+require 'workbook/modules/raw_objects_storage'
+
+module Workbook
+  class Format < Hash
+    include Workbook::Modules::RawObjectsStorage
+    alias_method :merge_hash, :merge
+    
+    attr_accessor :name
+    
+    def initialize options={}
+      options.each {|k,v| self[k]=v}
+    end
+    
+    def has_background_color? color=:any
+      if self[:background_color]
+        return (self[:background_color].downcase==color.to_s.downcase or (!(self[:background_color]==nil or (self[:background_color].is_a? String and (self[:background_color].downcase=='#ffffff' or self[:background_color]=='#000000'))) and color==:any))
+      else
+        return false
+      end
+    end
+    
+    # Returns a string that can be used as inline cell styling (e.g. `<td style="<%=cell.format.to_css%>"><%=cell%></td>`)
+    def to_css
+      css_parts = []
+      css_parts.push("background: #{self[:background_color].to_s} #{self[:background].to_s}".strip) if self[:background] or self[:background_color]
+      css_parts.push("color: #{self[:color].to_s}") if self[:color]
+      css_parts.join("; ")
+    end
+    
+    def merge(a)
+      self.remove_all_raws!
+      self.merge_hash(a)
+    end
+  end
+end

data/lib/workbook/modules/raw_objects_storage.rb

@@ -0,0 +1,31 @@
+module Workbook
+	module Modules
+		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
+	    end
+      
+      # Returns true if there is a template for a certain class, otherwise false
+	    def has_raw_for? raw_object_class
+	      raws.each { |tc,t| return true if tc == raw_object_class}
+        return false
+	    end
+      
+      def return_raw_for raw_object_class
+	      raws.each { |tc,t| return t if tc == raw_object_class}
+        return nil
+      end 
+      
+      def remove_all_raws!
+        @raws = {}
+      end
+      
+	    def raws
+        @raws = {} unless defined? @raws
+        @raws
+	    end
+		end
+	end
+end

data/lib/workbook/modules/table_diff_sort.rb

@@ -0,0 +1,140 @@
+# Adds diffing and sorting functions
+module Workbook
+	module Modules
+		module TableDiffSort
+      # create an overview of the differences between itself with another table, returns a book with a single sheet and table (containing the diffs)
+      def diff other, options={:sort=>true,:ignore_headers=>false}
+        
+        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
+        else
+          iteration_cols = (aother.header.to_symbols+aother.header.to_symbols).uniq
+        end
+        diff_table = diff_template.sheet.table
+        maxri = (aself.count-1)
+        for ri in 0..maxri do
+          row = diff_table[ri]
+          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]
+            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
+            
+            row[ci]=dcell
+          end
+        end
+        if !options[:ignore_headers]
+          diff_table[0].format = diff_template.template.create_or_find_format_by 'header'
+        end
+
+        diff_template
+      end
+      
+      def diff_template
+        return @diff_template if @diff_template
+        diffbook = Workbook::Book.new
+        difftable = diffbook.sheet.table
+        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
+        @diff_template = diffbook
+        return diffbook
+      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!
+        
+        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
+        
+        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}     
+      end
+      
+      # 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]
+          asd = -1
+        elsif sother[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
+        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 
+        if @placeholder_row != nil
+          return @placeholder_row 
+        else
+          @placeholder_row = Workbook::Row.new [nil]
+          placeholder_row.placeholder = true
+          return @placeholder_row 
+        end
+      end
+	  end
+	end
+end

data/lib/workbook/modules/type_parser.rb

@@ -0,0 +1,97 @@
+module Workbook
+  module Modules
+    module TypeParser
+      def strip_win_chars csv_raw
+        csv_raw.gsub(/(\n\r|\r\n|\r)/,"\n")
+      end
+      
+      def string_parsers
+        @string_parsers ||= [:string_cleaner,:string_nil_converter,:string_integer_converter,:string_boolean_converter]
+      end
+      
+      def string_parsers= arr
+        @string_parsers = arr
+      end
+      
+      def string_parsers_as_procs
+        string_parsers.collect{|c| c.is_a?(Proc) ? c : self.send(c)}
+      end
+      
+      def parse options={}
+        options = {:detect_date=>false}.merge(options)
+        string_parsers.push :string_optimistic_date_converter if options[:detect_date]
+        v = value
+        string_parsers_as_procs.each do |p|
+          if v.is_a? String
+            v = p.call(v)
+          end
+        end
+        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.gsub('mailto:','')
+        end
+      end
+      
+      def string_nil_converter
+        proc do |v|
+          return v == "" ? nil : v
+        end
+      end
+      
+      def string_integer_converter
+        proc do |v|
+          if v.to_i.to_s == v
+            return v.to_i
+          else
+            v
+          end
+        end
+      end
+      
+      def string_optimistic_date_converter
+        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
+          normal_date_length = v.to_s.length <= 25
+          if no_spaced_dash and starts_with_nr and normal_date_length
+            begin
+              rv = (v.length > 10) ? DateTime.parse(v) : Date.parse(v) 
+            rescue ArgumentError
+              rv = v
+            end
+            begin
+              rv = Date.parse(v.to_i.to_s) == rv ? v : rv # disqualify is it is only based on the first number
+            rescue ArgumentError
+            end
+          end          
+          rv
+        end
+      end
+      
+      def string_boolean_converter
+        proc do |v|
+          dv = v.downcase
+          if dv == "true"
+            return true
+          elsif dv == "false"
+            return false
+          end
+          v
+        end
+      end
+    end
+  end
+end

data/lib/workbook/readers/csv_reader.rb

@@ -0,0 +1,31 @@
+require 'faster_csv'
+
+module Workbook
+  module Readers
+    module CsvReader
+      def load_csv text
+        csv = text
+        parse_csv csv
+      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]
+        csv=nil
+        begin
+          csv = FasterCSV.parse(csv_raw,{:converters=>converters})
+        rescue
+          # we're going to have another shot at it...
+        end
+        
+        if csv==nil or csv[0].count == 1 
+          csv_excel = FasterCSV.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/txt_reader.rb

@@ -0,0 +1,17 @@
+require 'faster_csv'
+module Workbook
+  module Readers
+    module TxtReader
+      def load_txt text
+        csv = text
+        parse_txt csv        
+      end
+      
+      def parse_txt csv_raw
+        csv = []
+        csv_raw.split("\n").each {|l| csv << FasterCSV.parse_line(l,{:col_sep=>"\t"});nil}
+        self[0]=Workbook::Sheet.new(csv,self,{:parse_cells_on_batch_creation=>true, :cell_parse_options=>{:detect_date=>true}}) unless sheet.has_contents?
+      end
+    end
+  end
+end