oxcelix 0.3.2 → 0.3.3

data/lib/oxcelix/sax/comments.rb

@@ -1,28 +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
+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

@@ -1,17 +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
+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

@@ -1,49 +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
+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

@@ -1,78 +1,78 @@
-
-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)
-      if name == :c || name == :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
-      if name == :c || name == :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)
-      if @xmlstack.last == :c
-        @cell.send name, str if @cell.respond_to?(name)
-      elsif xmlstack.last == :mergeCell && name == :ref
-        @mergedcells << str
-      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
-end
+
+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)
+      if name == :c || name == :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
+      if name == :c || name == :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)
+      if @xmlstack.last == :c
+        @cell.send name, str if @cell.respond_to?(name)
+      elsif xmlstack.last == :mergeCell && name == :ref
+        @mergedcells << str
+      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
+end

data/lib/oxcelix/sheet.rb

@@ -1,75 +1,75 @@
-
-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
-    
-    # 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
- end
-end
+
+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
+    
+    # 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
+ end
+end