mindreframer-oxcelix 0.5.0

data/lib/oxcelix/numformats.rb

@@ -0,0 +1,115 @@
+module Oxcelix
+# The Numformats module provides helper methods that either return the Cell object's raw @value as a ruby value
+# (e.g. Numeric, DateTime, String) or formats it according to the excel _numformat_ string (#Cell.numformat).
+    module Numformats
+      # Map containing the Excel formatting strings and their ruby counterpart
+      Dtmap = {'hh'=>'%H', 'ii'=>'%M', 'i'=>'%-M', 'H'=>'%-k', 'h'=>'%-k',\
+                    'ss'=>'%-S', 's'=>'%S', 'mmmmm'=>'%b', 'mmmm'=>'%B', 'mmm'=>'%b', 'mm'=>'%m', \
+                    'm'=>'%-m', 'dddd'=>'%A', 'ddd'=>'%a', 'dd'=>'%d', 'd'=>'%-d', 'yyyy'=>'%Y', \
+                    'yy'=>'%y', 'AM/PM'=>'%p', 'A/P'=>'%p', '.0'=>'', 'ss'=>'%-S', 's'=>'%S'}
+
+      # Convert the temporary format array (the collection of non-default number formatting strings defined in the excel sheet in use)
+      # to a series of hashes containing an id, an excel format string, a converted format string and an object class the format is
+      # interpreted on.
+      def add_custom_formats fmtary
+        fmtary.each do |x|
+          if x[:formatCode] =~ /[#0%\?]/
+            ostring = numeric x[:formatCode]
+            if x[:formatCode] =~ /\//
+              cls = 'rational'
+            else
+              cls = 'numeric'
+            end
+          elsif x[:formatCode].downcase =~ /[dmysh]/
+            ostring = datetime x[:formatCode]
+            cls = 'date'
+          elsif x[:formatCode].downcase == "general"
+            ostring = nil
+            cls = 'string'
+          end
+          Formatarray << {:id => x[:numFmtId].to_s, :xl => x[:formatCode].to_s, :ostring => ostring, :cls => cls}
+        end
+      end
+      
+      # Convert the excel-style number format to a ruby #Kernel::Format string and return that String.
+      # The conversion is internally done by regexp'ing 7 groups: prefix, decimals, separator, floats, exponential (E+)
+      # and postfix. Rational numbers ar not handled yet.
+      # @param [String] val an Excel number format string.
+      # @return [String] a rubyish Kernel::Format string. 
+      def numeric val
+        ostring = "%"
+        strippedfmt = val.gsub(/\?/, '0').gsub(',','')
+        prefix, decimals, sep, floats, expo, postfix=/(^[^\#0e].?)?([\#0]*)?(\.)?([\#0]*)?(e.?)?(.?[^\#0e]$)?/i.match(strippedfmt).captures
+        ostring.prepend prefix.to_s
+        if !decimals.nil? && decimals.size != 0
+          if (eval decimals) == nil
+            ostring += "##{decimals.size}"
+          elsif (eval decimals) == 0
+            ostring += decimals.size.to_s
+          end
+        else
+          ostring += decimals
+        end
+        ostring += sep.to_s
+        if !floats.nil? && floats.size != 0 # expo!!!
+          ostring += ((floats.size.to_s) +"f")
+        end
+        if sep.nil? && floats.nil? || floats.size == 0
+          ostring += "d"
+        end
+        ostring += (expo.to_s + postfix.to_s) #postfix '+' ?
+        return ostring
+      end
+
+      # Convert excel-style date formats into ruby DateTime strftime format strings
+      # @param [String] formatcode an Excel number format string.
+      # @return [String] a DateTime::strftime format string.
+      def datetime formatcode
+        deminutified = formatcode.downcase.gsub(/(?<hrs>H|h)(?<div>.)m/, '\k<hrs>\k<div>i')
+                         .gsub(/im/, 'ii')
+                         .gsub(/m(?<div>.)(?<secs>s)/, 'i\k<div>\k<secs>')
+                         .gsub(/mi/, 'ii')
+        return deminutified.gsub(/[yMmDdHhSsi]*/, Dtmap)
+      end
+    end
+    
+    # The Numberhelper module implements methods that return the formatted value or the value converted into a Ruby type (DateTime, Numeric, etc)
+    module Numberhelper
+      include Numformats
+      # Get the cell's value and excel format string and return a string, a ruby Numeric or a DateTime object accordingly
+      # @return [Object] A ruby object that holds and represents the value stored in the cell. Conversion is based on cell formatting.
+      # @example Get the value of a cell:
+      #   c = w.sheets[0]["B3"] # => <Oxcelix::Cell:0x00000002a5b368 @xlcoords="A3", @style="84", @type="n", @value="41155", @numformat=14>
+      #   c.to_ru # => <DateTime: 2012-09-03T00:00:00+00:00 ((2456174j,0s,0n),+0s,2299161j)>
+      #
+      def to_ru
+        if !@value.numeric? || Numformats::Formatarray[@numformat.to_i][:xl] == nil || Numformats::Formatarray[@numformat.to_i][:xl].downcase == "general"
+          return @value
+        end
+        if Numformats::Formatarray[@numformat.to_i][:cls] == 'date'
+          return DateTime.new(1899, 12, 30) + (eval @value)
+        elsif Numformats::Formatarray[@numformat.to_i][:cls] == 'numeric' || Numformats::Formatarray[@numformat.to_i][:cls] == 'rational'
+            return eval @value rescue @value
+        end
+      end
+
+      # Get the cell's value, convert it with to_ru and finally, format it based on the value's type.
+      # @return [String] Value gets formatted depending on its class. If it is a DateTime, the #DateTime.strftime method is used,
+      # if it holds a number, the #Kernel::sprintf is run.
+      # @example Get the formatted value of a cell:
+      #   c = w.sheets[0]["B3"] # => <Oxcelix::Cell:0x00000002a5b368 @xlcoords="A3", @style="84", @type="n", @value="41155", @numformat=14>
+      #   c.to_fmt # => "3/9/2012"
+      #
+      def to_fmt
+        begin
+          if Numformats::Formatarray[@numformat.to_i][:cls] == 'date'
+              self.to_ru.strftime(Numformats::Formatarray[@numformat][:ostring]) rescue @value
+          elsif Numformats::Formatarray[@numformat.to_i][:cls] == 'numeric' || Numformats::Formatarray[@numformat.to_i][:cls] == 'rational'
+              sprintf(Numformats::Formatarray[@numformat][:ostring], self.to_ru) rescue @value
+          else
+            return @value
+          end
+        end
+      end
+    end
+  end

data/lib/oxcelix/sax/comments.rb

@@ -0,0 +1,28 @@
+module Oxcelix
+# The Comments class is a parser which builds an array of comments
+  class Comments < ::Ox::Sax
+    # @!attribute [rw] commarray
+    #   @return [Array] the array of all comments of a given sheet
+    # @!attribute [rw] comment
+    #   @return [Hash] a hash representing a comment
+    attr_accessor :commarray, :comment
+    def initialize
+      @commarray = []
+      @comment   = {}
+    end
+
+    # Push Cell comment hash (comment + reference) to @commarray
+    def text(str)
+      @comment[:comment] = str.gsub('&#10;', '')
+      @commarray << @comment
+      @comment = Hash.new
+    end
+
+    # Returns reference
+    def attr(name, str)
+      if name == :ref
+        @comment[:ref] = str
+      end
+    end
+  end
+end

data/lib/oxcelix/sax/sharedstrings.rb

@@ -0,0 +1,17 @@
+module Oxcelix
+  # Ox based SAX parser which pushes shared strings (taken from the sharedString.xml file) to an array
+  # These strings will replace the references in the cells (interpolation).
+  class Sharedstrings < ::Ox::Sax
+    # @!attribute [rw] stringarray
+    #   @return [Array] the array of all the strings found in sharedStrings.xml
+    attr_accessor :stringarray
+    def initialize
+      @stringarray = []
+    end
+
+    # Push the comment string into @stringarray
+    def text(str)
+      @stringarray << str
+    end
+  end
+end

data/lib/oxcelix/sax/styles.rb

@@ -0,0 +1,49 @@
+require 'ox'
+module Oxcelix
+
+  # Ox based SAX parser which pushes the number formats (taken from the styles.xml file) to an array
+  # The reference taken from the cell's 's' attribute points to an element of the
+  # style array, which in turn points to a number format (numFmt) that can be
+  # either built-in (@formats) or defined in the styles.xml itself.
+  class Styles < ::Ox::Sax
+    attr_accessor :styleary, :xmlstack, :temparray
+    def initialize
+      @temparray = []
+      @styleary  = []
+      @xmlstack  = []
+      @numform   = {}
+    end
+
+    def nf key, value
+      @numform[key]=value
+      if @numform.size == 2
+        @temparray << @numform
+        @numform = {}
+      end
+    end
+
+    def numFmtId str
+      if @xmlstack[-2] == :cellXfs
+        @styleary << str
+      elsif @xmlstack[-2] == :numFmts
+        nf :numFmtId, str
+      end
+    end
+
+    def formatCode str
+      nf :formatCode, str
+    end
+
+    def start_element(name)
+      @xmlstack << name
+    end
+
+    def end_element(name)
+      @xmlstack.pop
+    end
+
+    def attr(name, str)
+      self.send name, str if self.respond_to?(name)
+    end
+  end
+end

data/lib/oxcelix/sax/xlsheet.rb

@@ -0,0 +1,136 @@
+
+module Oxcelix
+  ##
+  # The Xlsheet class is a SAX parser based on the Ox library. It parses a
+  # SpreadsheetML (AKA Office Open XML) formatted XML file and returns an array
+  # of Cell objects {#cellarray} and an array of merged cells {#mergedcells}.
+  #
+  # Xlsheet will omit the following:
+  # * empty cells
+  # * cells containing formulas
+  #
+  # Only non-empty cells of merged groups will be added to {#cellarray}. A separate array
+  # {#mergedcells} is reserved for merging.
+  class Xlsheet < ::Ox::Sax
+  # @!attribute [rw] xmlstack
+  #   @return [Array] Stores the state machine's actual state
+  # @!attribute [rw] mergedcells
+  #   @return [Array] the array of merged cells
+  # @!attribute [rw] cellarray
+  #   @return [Array] the array of non-empty (meaningful) cells of the current sheet
+  # @!attribute [rw] cell
+  #   @return [Cell] the cell currently being processed.
+    attr_accessor :xmlstack, :mergedcells, :cellarray, :cell
+    def initialize()
+      @xmlstack    = []
+      @mergedcells = []
+      @cellarray   = []
+      @cell        = Cell.new
+    end
+
+    # Save SAX state-machine state to {#xmlstack} if and only if the processed
+    # element is a :c (column) or a :mergeCell (merged cell)
+    # @param [String] name Start element
+    def start_element(name)
+      case name
+      when :c
+        @xmlstack << name
+      when :mergeCell
+        @xmlstack << name
+      end
+    end
+
+    # Step back in the stack ({#xmlstack}.pop), clear actual cell information
+    # @param [String] name Element ends
+    def end_element(name)
+      @xmlstack.pop
+      case name
+      when :c
+        @cell = Cell.new
+      when :mergeCell
+        @cell = Cell.new
+      end
+    end
+
+    # Set cell value, style, etc. This will only happen if the cell has an
+    # actual value AND the parser's state is :c.
+    # If the state is :mergeCell AND the actual attribute name is :ref the
+    # attribute will be added to the merged cells array.
+    # The attribute name is tested against the Cell object: if the cell
+    # has a method named the same way, that method is called with the str parameter.
+    # @param [String] name of the attribute.
+    # @param [String] str Content of the attribute
+    def attr(name, str)
+      case @xmlstack.last
+      when :c
+        @cell.send name, str if @cell.respond_to?(name)
+      when :mergeCell
+        @mergedcells << str if name == :ref
+      end
+    end
+
+    # Cell content is parsed here. For cells containing strings, interpolation using the
+    # sharedStrings.xml file is done in the #Sharedstrings class.
+    # The numformat attribute gets a value here based on the styles variable, to preserve the numeric formatting (thus the type) of values.
+    def text(str)
+      if @xmlstack.last == :c
+        if @cell.type != "shared" && @cell.type != "e" && str.numeric?
+          @cell.v str
+          @cellarray << @cell
+        end
+        @cell = Cell.new
+      end
+    end
+  end
+
+  # A class that is inherited from the Xlsheet parser, but only parses a "page" of the given sheet.
+  # Its initialize will honor the per_page option (lines per page) and the pageno option (actual page to be parsed)
+  # Cells outside the actual page will be omitted from the parsing process. Mergegroups will only be included
+  # if the starting cell is within the actual page
+  class PagSheet < Xlsheet
+    attr_accessor :xmlstack, :mergedcells, :cellarray, :cell
+
+    def initialize(per_page, pageno)
+      @PER_PAGE = per_page
+      @PAGENO   = pageno
+      super()
+    end
+
+    def text(str)
+      if @xmlstack.last == :c
+        if @cell.type != "shared" && @cell.type != "e" && str.numeric? && ((@PER_PAGE * (@PAGENO-1)..(@PER_PAGE*@PAGENO-1)).include?@cell.y)
+          @cell.v str
+          @cellarray << @cell
+        end
+        @cell = Cell.new
+      end
+    end
+  end
+
+  # A class that is inherited from the Xlsheet parser, but only parses a given range of the given sheet.
+  # Its initialize will accept a range parameter. Cells outside this range will not be parsed at all.
+  # Mergegroups will only be included if the starting cell is within the selected range.
+  class Cellrange < Xlsheet
+    attr_accessor :xmlstack, :mergedcells, :cellarray, :cell
+
+    def initialize(range)
+      @cell        = Cell.new
+      @RANGE_START = range.begin
+      @RANGE_END   = range.end
+      super()
+    end
+
+    def text(str)
+      if @xmlstack.last == :c
+        if @cell.type != "shared" && @cell.type != "e" && str.numeric?
+          if (((@cell.x(@RANGE_START)..@cell.x(@RANGE_END)).include? @cell.x) && ((@cell.y(@RANGE_START)..@cell.y(@RANGE_END)).include? @cell.y))
+            @cell.v str
+            @cellarray << @cell
+          end
+        end
+        @cell = Cell.new
+      end
+    end
+
+  end
+end

data/lib/oxcelix/sheet.rb

@@ -0,0 +1,97 @@
+
+module Oxcelix
+  # The Sheet class represents an excel sheet.
+  class Sheet < Matrix
+    include Cellhelper
+    include Numberhelper
+
+    # @!attribute [rw] name
+    #   @return [String] Sheet name
+    # @!attribute [rw] sheetId
+    #   @return [String] returns the sheetId SheetML internal attribute
+    # @!attribute [rw] relationId
+    #   @return [String] Internal reference key. relationID is used internally by Excel 2010 to e.g. build up the relationship between worksheets and comments
+    attr_accessor :name, :sheetId, :relationId
+
+    # The [] method overrides the standard Matrix::[]. It will now accept Excel-style cell coordinates.
+    # @param [String] i
+    # @return [Cell] the object denoted with the Excel column-row name.
+    # @example Select a cell in a sheet
+    #   w = Oxcelix::Workbook.new('Example.xlsx')
+    #   w.sheets[0][3,1] #=> #<Oxcelix::Cell:0x00000001e00fa0 @xlcoords="B4", @style="0", @type="n", @value="3">
+    #   w.sheets[0]['B4'] #=> #<Oxcelix::Cell:0x00000001e00fa0 @xlcoords="B4", @style="0", @type="n", @value="3">
+    def [](i, *j)
+      if i.is_a? String
+        super(y(i),x(i))
+      else
+        super(i,j[0])
+      end
+    end
+
+    #The to_m method returns a simple Matrix object filled with the raw values of the original Sheet object.
+    # @return [Matrix] a collection of string values (the former #Cell::value)
+    def to_m(*attrs)
+      m = Matrix.build(self.row_size, self.column_size){nil}
+      self.each_with_index do |x, row, col|
+        if attrs.size == 0 || attrs.nil?
+          m[row, col] = x.value
+        end
+      end
+      return m
+    end
+
+    # The to_ru method returns a Matrix of "rubified" values. It basically builds a new Matrix
+    # and puts the result of the #Cell::to_ru method of every cell of the original sheet in
+    # the corresponding Matrix cell.
+    # @return [Matrix] a collection of ruby objects (#Integers, #Floats, #DateTimes, #Rationals, #Strings)
+    def to_ru
+      m = Matrix.build(self.row_size, self.column_size){nil}
+      self.each_with_index do |x, row, col|
+        if x.nil? || x.value.nil?
+          m[row, col] = nil
+        else
+          m[row, col] = x.to_ru
+        end
+      end
+      return m
+    end
+
+    # Invokes the #Cell::to_ru method on each element of self, replacing each element of the Sheet with the value returned.
+    def to_ru!
+      self.each_with_index do |x, row, col|
+        if x.nil? || x.value.nil?
+          self[row, col] = nil
+        else
+          self[row, col] = x.to_ru
+        end
+      end
+    end
+
+    # The to_fmt method returns a Matrix of "formatted" values. It basically builds a new Matrix
+    # and puts the result of the #Cell::to_fmt method of every cell of the original sheet in
+    # the corresponding Matrix cell. The #Cell::to_fmt will pass the original values to to_ru, and then
+    # depending on the value, will run strftime on DateTime objects and sprintf on numeric types.
+    # @return [Matrix] a collection of Strings
+    def to_fmt
+      m = Matrix.build(self.row_size, self.column_size){nil}
+      self.each_with_index do |x, row, col|
+        if x.nil? || x.value.nil?
+          m[row, col] = nil
+        else
+          m[row, col] = x.to_fmt
+        end
+      end
+      return m
+    end
+   # Invokes the #Cell::to_fmt method on each element of self, replacing each element of the Sheet with the value returned.
+    def to_fmt!
+      self.each_with_index do |x, row, col|
+        if x.nil? || x.value.nil?
+          self[row, col] = nil
+        else
+          self[row, col] = x.to_fmt
+        end
+      end
+    end
+  end
+end