oxcelix 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 gbiczo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+Oxcelix
+=======
+
+Oxcelix - A fast and simple .xlsx file parser
+
+Description
+-----------
+
+Oxcelix is an xlsx (Excel 2007/2010) parser. The result of the parsing is a
+Workbook which is an array of Sheet objects, which in turn store the data in
+Matrix objects. Matrices consist of Cell objects to maintain comments and
+formatting/style data
+
+Oxcelix uses the great Ox gem (http://rubygems.org/gems/ox) for fast SAX-parsing.
+
+Synopsis
+--------
+
+To process an xlsx file:
+
+`require 'oxcelix'`
+
+`w = Oxcelix::Workbook.new('whatever.xlsx')`
+
+To omit certain sheets:
+
+`w = Oxcelix::Workbook.new('whatever.xlsx', :exclude => ['sheet1', 'sheet2'])`
+
+To include only some of the sheets:
+
+`w = Oxcelix::Workbook.new('whatever.xlsx', :include => ['sheet1', 'sheet2', 'sheet3'])`
+
+To have the values of the merged cells copied over the mergegroup:
+
+`w = Oxcelix::Workbook.new('whatever.xlsx', :mergecells => true)`

data/README.rdoc

@@ -0,0 +1,30 @@
+= \Oxcelix - A fast .xlsx file parser
+
+== Description
+
+Oxcelix is an xlsx (Excel 2007/2010) parser. The result of the parsing is a
+Workbook which is an array of Sheet objects, which in turn store the data in
+Matrix objects. Matrices consist of Cell objects to maintain comments and
+formatting/style data
+.
+Oxcelix uses the great Ox gem (http://rubygems.org/gems/ox) for fast SAX-parsing.
+
+== Synopsis
+
+To process an xlsx file:
+
+  require 'oxcelix'
+  
+  w = Oxcelix::Workbook.new('whatever.xlsx')
+
+To omit certain sheets to be processed:
+
+  w = Oxcelix::Workbook.new('whatever.xlsx', :exclude => ['sheet1', 'sheet2'])
+
+To include only some of the sheets:
+
+  w = Oxcelix::Workbook.new('whatever.xlsx', :include => ['sheet1', 'sheet2', 'sheet3'])
+
+To have the values of the merged cells copied over the mergegroup:
+
+  w = Oxcelix::Workbook.new('whatever.xlsx', :mergecells => true)

data/lib/oxcelix/cell.rb

@@ -0,0 +1,17 @@
+module Oxcelix
+  # Simple class representing an excel cell.
+  # @!attribute [rw] xlcoords
+  #   @return [String] The Excel-style coordinates of the cell object
+  # @!attribute [rw] type
+  #   @return [String] Cell content type
+  # @!attribute [rw] value
+  #   @return [String] the type of the cell
+  # @!attribute [rw] comment
+  #   @return [String] Comment text
+  # @!attribute [rw] style
+  #   @return [String] Excel style attribute
+  class Cell
+    attr_accessor :xlcoords, :type, :value, :comment, :style
+    include Cellhelper
+  end
+end

data/lib/oxcelix/cellhelper.rb

@@ -0,0 +1,45 @@
+
+module Oxcelix
+  # The Cellhelper module defines some methods useful to manipulate Cell objects
+  module Cellhelper
+    # Set the excel cell name (eg: 'A2')
+    # @param [String] val Excel cell address name
+    def r(val); @xlcoords = val; end;
+    # Set cell type    
+    def t(val); @type = val; end;
+    # Set cell value
+    def v(val); @value = val; end;
+    # Set cell style (number format and style) 
+    def s(val); @style = val; end;
+    
+    # When called without parameters, returns the x coordinate of the calling cell object based on the value of #@xlcoords
+    # If a parameter is given, #x will return the x coordinate corresponding to the parameter
+    # @example find x coordinate (column number) of a cell
+    #   c = Cell.new
+    #   c.xlcoords = ('B3')
+    #   c.x #=> 1
+    # @param [String] coord Optional parameter used when method is not called from a Cell object
+    # @return [Integer] x coordinate
+    def x(coord=nil)
+      if coord.nil?
+        coord = @xlcoords
+      end
+      ('A'..(coord.scan(/\p{Alpha}+|\p{Digit}+/u)[0])).to_a.length-1
+    end
+
+    # When called without parameters, returns the y coordinate of the calling cell object based on the value of #@xlcoords
+    # If a parameter is given, #y will return the y coordinate corresponding to the parameter
+    # @example find y coordinate (row number) of a cell
+    #   c = Cell.new
+    #   c.xlcoords = ('B3')
+    #   c.y #=> 2
+    # @param [String] coord Optional parameter used when method is not called from a Cell object
+    # @return [Integer] x coordinate
+    def y(coord=nil)
+      if coord.nil?
+        coord = @xlcoords
+      end
+      coord.scan(/\p{Alpha}+|\p{Digit}+/u)[1].to_i-1
+    end
+  end
+end

data/lib/oxcelix/sax/comments.rb

@@ -0,0 +1,24 @@
+module Oxcelix
+# The Comments class is a parser which builds an array of comments
+  class Comments < ::Ox::Sax
+    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,15 @@
+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
+    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/xlsheet.rb

@@ -0,0 +1,77 @@
+
+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
+
+    # String type cell content is parsed here. String interpolation using the
+    # sharedStrings.xml file is done in the #Sharedstrings class
+    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

@@ -0,0 +1,17 @@
+
+module Oxcelix
+  # The Sheet class represents an excel sheet.
+  # @!attribute [rw] name
+  #   @return [String] Sheet name
+  # @!attribute [rw] sheetId
+  #   @return [String] returns the sheetId SheetML internal attribute
+  # @!attribute [rw] relationId
+  #   @return [String] returns the relation key used to reference the comments file related to a certain sheet.
+  # @!attribute [rw] data
+  #   @return [Array] stores the collection of cells of a certain sheet. This is the copy of the sum of cellarray and mergedcells.
+  #   This is laterconverted to a matrix
+  class Sheet
+    attr_accessor :name, :sheetId, :relationId, :data
+    def initialize; @data=[]; end
+  end
+end

data/lib/oxcelix/workbook.rb

@@ -0,0 +1,219 @@
+# The namespace for all classes and modules included on Oxcelix.
+module Oxcelix
+  # Helper methods for the Workbook class
+  module Workbookhelper
+    # returns a sheet based on its name
+
+    # @example Select a sheet
+    #   w = Workbook.new('Example.xlsx')
+    #   sheet = w["Examplesheet"]
+    def [] (sheetname=String)
+      @sheets.select{|s| s.name==sheetname}[0]
+    end
+  end
+
+  # The Workbook class will open the excel file, and convert it to a collection of
+  # Matrix objects
+  # @!attribute [rw] sheetbase
+  #   @return [Hash] sheetbase Single sheet metadata - will be obsolete in the future
+  # @!attribute [rw] sheets
+  #   @return [Array] sheets Collection of {Sheet} objects 
+  # @!attribute [rw] sharedstrings
+  #   @return [Sharedstrings] sharedstrings returns a {Sharedstrings} object used to interpolate string indexes with their actual value. 
+  class Workbook
+    include Cellhelper
+    include Workbookhelper
+    attr_accessor :sheetbase, :sheets, :sharedstrings
+    ##
+    # Create a new Workbook object.
+    #
+    # filename is the name of the Excel 2007/2010 file to be opened (xlsx)
+    #
+    # options is a collection of options that can be passed to Workbook.
+    # Options may include:
+    # * :copymerge (=> true/false) - Copy and repeat the content of the merged cells into the whole group, e.g. 
+    # the group of three merged cells <tt>|   a   |</tt> will become <tt>|a|a|a|</tt>
+    # * :include (Ary) - an array of sheet names to be included
+    # * :exclude (Ary) - an array of sheet names not to be processed
+    #
+    # The excel file is first getting unzipped, then the workbook.xml file gets
+    # processed. This file stores sheet metadata, which will be filtered (by including
+    # and excluding sheets from further processing)
+    #
+    # The next stage is building sheets.
+    # This includes:
+    # * Parsing the XML files representing the sheets
+    # * Interpolation of the shared strings
+    # * adding comments to the cells
+    # * Converting each sheet to a Matrix object
+    def initialize(filename, options={})
+      @destination = Dir.pwd+'/tmp'
+      FileUtils.mkdir(@destination)
+      Zip::File.open(filename){ |zip_file|
+        zip_file.each{ |f| 
+          f_path=File.join(@destination, f.name)
+          FileUtils.mkdir_p(File.dirname(f_path))
+          zip_file.extract(f, f_path) unless File.exists?(f_path)
+        }
+      }
+      @sheets=[]
+      @sheetbase={}
+      @a=Ox::load_file(@destination+'/xl/workbook.xml')
+      
+      sheetdata(options); commentsrel; shstrings;
+      @sheets.each do |x|
+        sname="sheet#{x[:sheetId]}"
+        @sheet = Xlsheet.new()
+        File.open(@destination+"/xl/worksheets/#{sname}.xml", 'r') do |f|
+          Ox.sax_parse(@sheet, f)
+        end
+        comments=
+        mkcomments(x[:comments])
+        @sheet.cellarray.each do |sh|
+          if sh.type=="s"
+            sh.value = @sharedstrings[sh.value.to_i]
+          end
+          if !comments.nil?
+            comm=comments.select {|c| c[:ref]==(sh.xlcoords)}
+            if comm.size > 0
+              sh.comment=comm
+            end
+            comments.delete_if{|c| c[:ref]==(sh.xlcoords)}
+          end
+        end
+        x[:cells] = @sheet.cellarray
+        x[:mergedcells] = @sheet.mergedcells
+      end
+      FileUtils.remove_dir(@destination, true)
+      matrixto(options[:copymerge])
+    end
+    
+    private
+    # @private
+    # Given the data found in workbook.xml, create a hash and push it to the sheets
+    # array.
+    #
+    # The hash will not be pushed into the array if the sheet name is blacklisted
+    # (it appears in the *excluded_sheets* array) or does not appear in the list of
+    # included sheets.
+    #
+    # If *included_sheets* (the array of whitelisted sheets) is *nil*, the hash is added.
+    def sheetdata options={}
+      @a.locate("workbook/sheets/*").each do |x|
+        @sheetbase[:name] = x[:name]
+        @sheetbase[:sheetId] = x[:sheetId]
+        @sheetbase[:relationId] = x[:"r:id"]
+        @sheets << @sheetbase
+        @sheetbase=Hash.new
+      end
+      sheetarr=@sheets.map{|i| i[:name]}
+      if options[:include].nil?; options[:include]=[]; end
+      if options[:include].to_a.size>0
+        sheetarr.keep_if{|item| options[:include].to_a.detect{|d| d==item}}
+      end
+      sheetarr=sheetarr-options[:exclude].to_a
+      @sheets.keep_if{|item| sheetarr.detect{|d| d==item[:name]}}
+      @sheets.uniq!
+    end
+    
+    # Build the relationship between sheets and the XML files storing the comments
+    # to the actual sheet.
+    def commentsrel #!!!MI VAN HA NINCS KOMMENT???????
+     unless Dir[@destination + '/xl/worksheets/_rels'].empty?
+      Find.find(@destination + '/xl/worksheets/_rels') do |path|
+        if File.basename(path).split(".").last=='rels'
+          f=Ox.load_file(path)
+          f.locate("Relationships/*").each do |x|
+            if x[:Target].include?"comments"
+              @sheets.each do |s|
+                if File.basename(path,".rels")=="sheet"+s[:sheetId]+".xml"
+                  s[:comments]=x[:Target]
+                end
+              end
+            end
+          end
+        end
+      end
+     else
+       @sheets.each do |s|
+         s[:comments]=nil
+       end
+     end
+    end
+
+    # Invokes the Sharedstrings helper class
+    def shstrings
+      strings = Sharedstrings.new()
+      File.open(@destination + '/xl/sharedStrings.xml', 'r') do |f|
+        Ox.sax_parse(strings, f)
+      end
+      @sharedstrings=strings.stringarray
+    end
+    
+    # Parses the comments related to the actual sheet.  
+    # @param [String] commentfile
+    # @return [Array] a collection of comments relative to the Excel sheet currently processed
+    def mkcomments(commentfile)
+      unless commentfile.nil?
+        comms = Comments.new()
+        File.open(@destination + '/xl/'+commentfile.gsub('../', ''), 'r') do |f|
+          Ox.sax_parse(comms, f)
+        end
+        return comms.commarray
+      end
+    end
+
+    # Returns an array of Matrix objects.
+    # For each sheet, matrixto first checks the address (xlcoords) of the
+    # last cell in the cellarray, then builds a *nil*-filled Matrix object of
+    # size *xlcoords.x, xlcoords.y*.
+    #
+    # The matrix will then be filled with Cell objects according to their coordinates.
+    #
+    # If the *copymerge* parameter is *true*, it creates a submatrix (minor)
+    # of every mergegroup (based on the mergedcells array relative to the actual
+    # sheet), and after the only meaningful cell of the minor is found, it is
+    # copied back to the remaining cells of the group. The coordinates (xlcoords)
+    # of each copied cell is changed to reflect the actual Excel coordinate.
+    # 
+    # The matrix will replace the array of cells in the actual sheet.
+    # @param [Bool ] copymerge 
+    # @return [Matrix] a Matrix that stores the cell values, and, depending on the copymerge parameter, will copy the merged value
+    #  into every merged cell
+    def matrixto(copymerge)
+      @sheets.each_with_index do |sheet, i|
+        m=Matrix.build(sheet[:cells].last.y+1, sheet[:cells].last.x+1) {nil}
+        sheet[:cells].each do |c|
+          m[c.y, c.x]=c
+        end
+        if copymerge==true
+          sheet[:mergedcells].each do |mc|
+            a = mc.split(':')
+            x1=x(a[0])
+            y1=y(a[0])
+            x2=x(a[1])
+            y2=y(a[1])
+            mrange=m.minor(y1..y2, x1..x2)
+            valuecell=mrange.to_a.flatten.compact[0]
+            (x1..x2).each do |col|
+              (y1..y2).each do |row|
+                if valuecell != nil
+                  valuecell.xlcoords=(col.col_name)+(row+1).to_s
+                  m[col, row]=valuecell
+                else
+                  valuecell=Cell.new
+                  valuecell.xlcoords=(col.col_name)+(row+1).to_s
+                  m[col, row]=valuecell
+                end
+              end
+            end
+          end
+        end
+        s=Sheet.new
+        s.name=@sheets[i][:name]; s.sheetId=@sheets[i][:sheetId]; s.relationId=@sheets[i][:relationId]
+        s.data=m
+        @sheets[i]=s
+      end
+    end
+  end
+end

data/lib/oxcelix.rb

@@ -0,0 +1,44 @@
+require 'ox'
+require 'find'
+require 'matrix'
+require 'fileutils'
+require 'zip'
+require 'oxcelix/cellhelper'
+require 'oxcelix/cell'
+require 'oxcelix/sheet'
+require 'oxcelix/workbook'
+require 'oxcelix/sax/sharedstrings'
+require 'oxcelix/sax/comments'
+require 'oxcelix/sax/xlsheet'
+
+class String
+  # Returns true if the given String represents a numeric value 
+  # @return [Bool]
+  def numeric?
+    Float(self) != nil rescue false
+  end
+end
+
+class Matrix
+  # Set the cell value i,j to x, where i=row, and j=column.
+  # @param i [Integer] Row
+  # @param j [Integer] Column
+  # @param x [Object] New cell value
+  def []=(i, j, x)
+    @rows[i][j]=x
+  end
+end
+
+class Fixnum
+  # Returns the column name corresponding to the given number. e.g: 1.col_name => 'B'
+  # @return [String]
+  def col_name
+    val=self/26
+    (val > 0 ? (val - 1).col_name : "") + (self % 26 + 65).chr
+  end
+end
+
+# The namespace for all classes and modules included in Oxcelix.
+module Oxcelix
+
+end

data/oxcelix.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+
+require 'rake'
+Gem::Specification.new do |s|
+  s.name	= 'oxcelix'
+  s.version	= '0.1.0'
+  s.date	= '2013-10-06'
+  s.summary	= 'A fast Excel 2007/2010 file parser'
+  s.description	= 'A fast .xlsx file  parser that returns a collection of Matrix objects'
+  s.authors	= 'Giovanni Biczo'
+  s.homepage	= 'http://github.com/gbiczo/oxcelix'
+  s.rubyforge_project = 'oxcelix'
+
+  s.files	= FileList["LICENSE", "README.rdoc", "README.md",
+		  "lib/*", "lib/oxcelix/*", "lib/oxcelix/sax/*",
+		  "oxcelix.gemspec", "spec/*"].to_a
+  s.license	= 'MIT'
+  
+  s.add_runtime_dependency "ox", [">= 2.0.6"]
+  s.add_runtime_dependency "rubyzip", [">= 0.9.9"]
+end

data/spec/cell_spec.rb

@@ -0,0 +1,13 @@
+#require './spec_helper'
+require '../oxcelix.rb'
+ describe "Cell object" do
+  describe '#r' do
+    it "sets the value of xlcoords" do
+      c=Oxcelix::Cell.new
+      c.r('H276')
+      c.xlcoords.should=='H276'
+      c.x.should==7
+      c.y.should==275
+    end
+  end
+end

data/spec/fixnum_spec.rb

@@ -0,0 +1,11 @@
+#require './spec_helper'
+require '../oxcelix.rb'
+ describe "Fixnum object" do
+  describe '#col_name' do
+    it "returns a string representing an excel column name" do
+      (0..25).each do |x|
+        x.col_name.should == ('A'..'Z').to_a[x]
+      end
+    end
+  end
+end

data/spec/matrix_spec.rb

@@ -0,0 +1,11 @@
+#require './spec_helper'
+require '../oxcelix.rb'
+ describe "Matrix object" do
+  describe '#[]=' do
+    it "should set a cell to a new value" do
+     m_obj=Matrix.build(4, 4){nil}
+     m_obj[3,3]='foo'
+     m_obj[3,3].should == 'foo'
+  end
+  end
+end

data/spec/oxcelix_spec.rb

@@ -0,0 +1,36 @@
+#require './spec_helper'
+require '../oxcelix.rb'
+ describe "Oxcelix module" do
+# before :all do
+ describe 'Workbook' do
+    context 'normal' do
+      it "should open the excel file and return a Workbook object" do
+        file = './test.xlsx'
+        w=Oxcelix::Workbook.new(file)
+        w.sheets.size.should == 2
+        w.sheets[0].name.should=="Testsheet1"
+        w.sheets[1].name.should=="Testsheet2"
+      end
+    end
+    context 'with excluded sheets' do
+      it "should open the sheets not excluded of the excel file" do
+        file = './test.xlsx'
+        w=Oxcelix::Workbook.new(file, {:exclude=>['Testsheet2']})
+        w.sheets.size.should==1
+        w.sheets[0].name.should=="Testsheet1"
+        end
+    end
+    context 'with included sheets' do
+      it "should open only the included sheets of the excel file" do
+        file = './test.xlsx'
+        w=Oxcelix::Workbook.new(file, {:include=>['Testsheet2']})
+        w.sheets.size.should==1
+        w.sheets[0].name.should=="Testsheet2"
+      end
+    end
+    context 'with merged cells copied group-wide'
+      it "should open the excel file and copy the merged cells trough the mergegroup" do
+      end
+    end
+#  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require_relative '../oxcelix'
+
+require 'yaml'

data/spec/string_spec.rb

@@ -0,0 +1,19 @@
+#require './spec_helper'
+require '../oxcelix.rb'
+ describe "String object" do
+  describe 'numeric?' do
+    context "with numbers" do
+     it "should return true" do
+      (1..100).each do |x|
+        x.to_s.numeric?.should == true
+      end
+    end
+    context "with strings"
+     it "should return false" do
+      ('a'..'zz').each do |x|
+        x.numeric?.should == false
+     end
+     end
+    end
+  end
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: oxcelix
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Giovanni Biczo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.6
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.9
+description: A fast .xlsx file  parser that returns a collection of Matrix objects
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.rdoc
+- README.md
+- lib/oxcelix.rb
+- lib/oxcelix/cell.rb
+- lib/oxcelix/workbook.rb
+- lib/oxcelix/sheet.rb
+- lib/oxcelix/cellhelper.rb
+- lib/oxcelix/sax/sharedstrings.rb
+- lib/oxcelix/sax/xlsheet.rb
+- lib/oxcelix/sax/comments.rb
+- oxcelix.gemspec
+- spec/test.xlsx
+- spec/spec_helper.rb
+- spec/fixnum_spec.rb
+- spec/oxcelix_spec.rb
+- spec/cell_spec.rb
+- spec/matrix_spec.rb
+- spec/string_spec.rb
+homepage: http://github.com/gbiczo/oxcelix
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: oxcelix
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: A fast Excel 2007/2010 file parser
+test_files: []
+has_rdoc: