oxcelix 0.3.3 → 0.4.0

data/lib/oxcelix/numformats.rb

@@ -1,114 +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
-      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] val 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)
-        else 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][: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
+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

@@ -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,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)
-      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)
+      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