simple_xlsx_reader 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Woody Peterson
+
+MIT License
+
+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,100 @@
+# SimpleXlsxReader
+
+An xlsx reader for Ruby that parses xlsx cell values into plain ruby
+primitives and dates/times.
+
+This is *not* a rewrite of excel in Ruby. Font styles, for
+example, are parsed to determine whether a cell is a number or a date,
+then forgotten. We just want to get the data, and get out!
+
+## Usage
+
+### Summary:
+
+    doc = SimpleXlsxReader.open('/path/to/workbook.xlsx')
+    doc.sheets # => [<#SXR::Sheet>, ...]
+    doc.sheets.first.name # 'Sheet1'
+    doc.sheets.first.rows # [['Header 1', 'Header 2', ...]
+                             ['foo', 2, ...]]
+
+That's it!
+
+### Load Errors
+
+By default, cell load errors (ex. if a date cell contains the string
+'hello') result in a SimpleXlsxReader::CellLoadError.
+
+If you would like to provide better error feedback to your users, you
+can set `SimpleXlsxReader.configuration.catch_cell_load_errors =
+true`, and load errors will instead be inserted into Sheet#load_errors keyed
+by [rownum, colnum].
+
+### More
+
+Here's the totality of the public api, in code:
+
+    module SimpleXlsxReader
+      def self.open(file_path)
+        Document.new(file_path).tap(&:sheets)
+      end
+
+      class Document
+        attr_reader :file_path
+
+        def initialize(file_path)
+          @file_path = file_path
+        end
+
+        def sheets
+          @sheets ||= Mapper.new(xml).load_sheets
+        end
+
+        def to_hash
+          sheets.inject({}) {|acc, sheet| acc[sheet.name] = sheet.rows; acc}
+        end
+
+        def xml
+          Xml.load(file_path)
+        end
+
+        class Sheet < Struct.new(:name, :rows)
+          def headers
+            rows[0]
+          end
+
+          def data
+            rows[1..-1]
+          end
+
+          # Load errors will be a hash of the form:
+          # {
+          #   [rownum, colnum] => '[error]'
+          # }
+          def load_errors
+            @load_errors ||= {}
+          end
+        end
+      end
+    end
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'simple_xlsx_reader'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simple_xlsx_reader
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
+end
+
+task :default => [:test]

data/lib/simple_xlsx_reader.rb

@@ -0,0 +1,354 @@
+require "simple_xlsx_reader/version"
+require 'nokogiri'
+require 'zip/zip'
+require 'zip/zipfilesystem'
+require 'date'
+
+module SimpleXlsxReader
+  class CellLoadError < StandardError; end
+
+  def self.configuration
+    @configuration ||= Struct.new(:catch_cell_load_errors).new.tap do |c|
+      c.catch_cell_load_errors = false
+    end
+  end
+
+  def self.open(file_path)
+    Document.new(file_path).tap(&:sheets)
+  end
+
+  class Document
+    attr_reader :file_path
+
+    def initialize(file_path)
+      @file_path = file_path
+    end
+
+    def sheets
+      @sheets ||= Mapper.new(xml).load_sheets
+    end
+
+    def to_hash
+      sheets.inject({}) {|acc, sheet| acc[sheet.name] = sheet.rows; acc}
+    end
+
+    def xml
+      Xml.load(file_path)
+    end
+
+    class Sheet < Struct.new(:name, :rows)
+      def headers
+        rows[0]
+      end
+
+      def data
+        rows[1..-1]
+      end
+
+      # Load errors will be a hash of the form:
+      # {
+      #   [rownum, colnum] => '[error]'
+      # }
+      def load_errors
+        @load_errors ||= {}
+      end
+    end
+
+    ##
+    # For internal use; stores source xml in nokogiri documents
+    class Xml
+      attr_accessor :workbook, :shared_strings, :sheets, :styles
+
+      def self.load(file_path)
+        self.new.tap do |xml|
+          Zip::ZipFile.open(file_path) do |zip|
+            xml.workbook       = Nokogiri::XML(zip.read('xl/workbook.xml'))
+            xml.styles         = Nokogiri::XML(zip.read('xl/styles.xml'))
+
+            # optional feature used by excel, but not often used by xlsx
+            # generation libraries
+            if zip.file.file?('xl/sharedStrings.xml')
+              xml.shared_strings = Nokogiri::XML(zip.read('xl/sharedStrings.xml'))
+            end
+
+            xml.sheets = []
+            i = 0
+            loop do
+              i += 1
+              break if !zip.file.file?("xl/worksheets/sheet#{i}.xml")
+
+              xml.sheets <<
+                Nokogiri::XML(zip.read("xl/worksheets/sheet#{i}.xml"))
+            end
+          end
+        end
+      end
+    end
+
+    ##
+    # For internal use; translates source xml to Sheet objects.
+    class Mapper < Struct.new(:xml)
+      def load_sheets
+        sheet_toc.map do |(sheet_name, sheet_number)|
+          parse_sheet(sheet_name, xml.sheets[sheet_number])
+        end
+      end
+
+      # Table of contents for the sheets, ex. {'Authors' => 0, ...}
+      def sheet_toc
+        xml.workbook.xpath('/xmlns:workbook/xmlns:sheets/xmlns:sheet').
+          inject({}) do |acc, sheet|
+
+          acc[sheet.attributes['name'].value] =
+            sheet.attributes['sheetId'].value.to_i - 1 # keep things 0-indexed
+
+          acc
+        end
+      end
+
+      def parse_sheet(sheet_name, xsheet)
+        sheet = Sheet.new(sheet_name)
+
+        rownum = -1
+        sheet.rows =
+          xsheet.xpath("/xmlns:worksheet/xmlns:sheetData/xmlns:row").map do |xrow|
+          rownum += 1
+
+          colnum = -1
+          xrow.xpath('xmlns:c').map do |xcell|
+            colnum += 1
+
+            type = xcell.attributes['t'] &&
+                   xcell.attributes['t'].value
+            # If not the above, attempt to determine from a custom style
+            type ||= xcell.attributes['s'] &&
+                     style_types[xcell.attributes['s'].value.to_i]
+
+            begin
+              self.class.cast(xcell.text, type, shared_strings: shared_strings)
+            rescue => e
+              if !SimpleXlsxReader.configuration.catch_cell_load_errors
+                error = CellLoadError.new(
+                  "Row #{rownum}, Col #{colnum}: #{e.message}")
+                error.set_backtrace(e.backtrace)
+                raise error
+              else
+                sheet.load_errors[[rownum, colnum]] = e.message
+
+                xcell.text
+              end
+            end
+          end
+        end
+
+        sheet
+      end
+
+      # Excel doesn't record types for some cells, only its display style, so
+      # we have to back out the type from that style.
+      #
+      # Some of these styles can be determined from a known set (see NumFmtMap), 
+      # while others are 'custom' and we have to make a best guess.
+      #
+      # This is the array of types corresponding to the styles a spreadsheet
+      # uses, and includes both the known style types and the custom styles.
+      #
+      # Note that the xml sheet cells that use this don't reference the
+      # numFmtId, but instead the array index of a style in the stored list of
+      # only the styles used in the spreadsheet (which can be either known or
+      # custom). Hence this style types array, rather than a map of numFmtId to
+      # type.
+      def style_types
+        @style_types ||=
+          xml.styles.xpath('/xmlns:styleSheet/xmlns:cellXfs/xmlns:xf').map {|xstyle|
+            style_type_by_num_fmt_id(xstyle.attributes['numFmtId'].value)}
+      end
+
+      # Finds the type we think a style is; For example, fmtId 14 is a date
+      # style, so this would return :date
+      def style_type_by_num_fmt_id(id)
+        return nil if id.nil?
+
+        id = id.to_i
+        if id > 164 # custom style, arg!
+          custom_style_types[id]
+        else # we should know this one
+          NumFmtMap[id]
+        end
+      end
+
+      # Map of (numFmtId > 164) (custom styles) to our best guess at the type
+      # ex. {165 => :date_time}
+      def custom_style_types
+        @custom_style_types ||=
+          xml.styles.xpath('/xmlns:styleSheet/xmlns:numFmts/xmlns:numFmt').
+          inject({}) do |acc, xstyle|
+
+          acc[xstyle.attributes['numFmtId'].value.to_i] =
+            determine_custom_style_type(xstyle.attributes['formatCode'].value)
+
+          acc
+        end
+      end
+
+      # This is the least deterministic part of reading xlsx files. Due to
+      # custom styles, you can't know for sure when a date is a date other than
+      # looking at its format and gessing. It's not impossible to guess right,
+      # though.
+      #
+      # http://stackoverflow.com/questions/4948998/determining-if-an-xlsx-cell-is-date-formatted-for-excel-2007-spreadsheets
+      def determine_custom_style_type(string)
+        return :float if string[0] == '_'
+        return :float if string[0] == ' 0'
+
+        # Looks for one of ymdhis outside of meta-stuff like [Red]
+        return :date_time if string =~ /(^|\])[^\[]*[ymdhis]/i
+
+        return :unsupported
+      end
+
+      ##
+      # The heart of typecasting. The ruby type is determined either explicitly
+      # from the cell xml or implicitly from the cell style, and this
+      # method expects that work to have been done already. This, then,
+      # takes the type we determined it to be and casts the cell value
+      # to that type.
+      #
+      # types:
+      # - s: shared string (see #shared_string)
+      # - n: number (cast to a float)
+      # - b: boolean
+      # - str: string
+      # - inlineStr: string
+      # - ruby symbol: for when type has been determined by style
+      #
+      # options:
+      # - shared_strings: needed for 's' (shared string) type
+      def self.cast(value, type, options = {})
+        return nil if value.nil? || value.empty?
+
+        case type
+
+        ##
+        # There are few built-in types
+        ##
+
+        when 's' # shared string
+          options[:shared_strings][value.to_i]
+        when 'n' # number
+          value.to_f
+        when 'b'
+          value.to_i == 1
+        when 'str'
+          value
+        when 'inlineStr'
+          value
+
+        ##
+        # Type can also be determined by a style,
+        # detected earlier and cast here by its standardized symbol
+        ##
+
+        when :string, :unsupported
+          value
+        when :fixnum
+          value.to_i
+        when :float
+          value.to_f
+        when :percentage
+          value.to_f / 100
+        # the trickiest. note that  all these formats can vary on
+        # whether they actually contain a date, time, or datetime.
+        when :date, :time, :date_time
+          days_since_1900, fraction_of_24 = value.split('.')
+
+          # http://stackoverflow.com/questions/10559767/how-to-convert-ms-excel-date-from-float-to-date-format-in-ruby
+          date = Date.new(1899, 12, 30) + Integer(days_since_1900)
+
+          if fraction_of_24 # there is a time associated
+            fraction_of_24 = "0.#{fraction_of_24}".to_f
+            military       = fraction_of_24 * 24
+            hour           = military.truncate
+            minute         = ((military % 1) * 60).truncate
+
+            return Time.utc(date.year, date.month, date.day, hour, minute)
+          else
+            return date
+          end
+        when :bignum
+          if defined?(BigDecimal)
+            BigDecimal.new(value)
+          else
+            value.to_f
+          end
+
+        ##
+        # Beats me
+        ##
+
+        else
+          value
+        end
+      end
+
+      # Map of non-custom numFmtId to casting symbol
+      NumFmtMap = {
+        0  => :string,         # General
+        1  => :fixnum,         # 0
+        2  => :float,          # 0.00
+        3  => :fixnum,         # #,##0
+        4  => :float,          # #,##0.00
+        5  => :unsupported,    # $#,##0_);($#,##0)
+        6  => :unsupported,    # $#,##0_);[Red]($#,##0)
+        7  => :unsupported,    # $#,##0.00_);($#,##0.00)
+        8  => :unsupported,    # $#,##0.00_);[Red]($#,##0.00)
+        9  => :percentage,     # 0%
+        10 => :percentage,     # 0.00%
+        11 => :bignum,         # 0.00E+00
+        12 => :unsupported,    # # ?/?
+        13 => :unsupported,    # # ??/??
+        14 => :date,           # mm-dd-yy
+        15 => :date,           # d-mmm-yy
+        16 => :date,           # d-mmm
+        17 => :date,           # mmm-yy
+        18 => :time,           # h:mm AM/PM
+        19 => :time,           # h:mm:ss AM/PM
+        20 => :time,           # h:mm
+        21 => :time,           # h:mm:ss
+        22 => :date_time,      # m/d/yy h:mm
+        37 => :unsupported,    # #,##0 ;(#,##0)
+        38 => :unsupported,    # #,##0 ;[Red](#,##0)
+        39 => :unsupported,    # #,##0.00;(#,##0.00)
+        40 => :unsupported,    # #,##0.00;[Red](#,##0.00)
+        45 => :time,           # mm:ss
+        46 => :time,           # [h]:mm:ss
+        47 => :time,           # mmss.0
+        48 => :bignum,         # ##0.0E+0
+        49 => :unsupported     # @
+      }
+
+      # For performance reasons, excel uses an optional SpreadsheetML feature
+      # that puts all strings in a separate xml file, and then references
+      # them by their index in that file.
+      #
+      # http://msdn.microsoft.com/en-us/library/office/gg278314.aspx
+      def shared_strings
+        @shared_strings ||= begin
+          if xml.shared_strings
+            xml.shared_strings.xpath('/xmlns:sst/xmlns:si').map do |xsst|
+              # a shared string can be a single value...
+              sst = xsst.xpath('xmlns:t/text()').first
+              sst = sst.text if sst
+              # ... or a composite of seperately styled words/characters
+              sst ||= xsst.xpath('xmlns:r/xmlns:t/text()').map(&:text).join
+            end
+          else
+            []
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/simple_xlsx_reader/version.rb

@@ -0,0 +1,3 @@
+module SimpleXlsxReader
+  VERSION = "0.0.1"
+end

data/simple_xlsx_reader.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'simple_xlsx_reader/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "simple_xlsx_reader"
+  gem.version       = SimpleXlsxReader::VERSION
+  gem.authors       = ["Woody Peterson"]
+  gem.email         = ["woody@sigby.com"]
+  gem.description   = %q{Read xlsx data the Ruby way}
+  gem.summary       = %q{Read xlsx data the Ruby way}
+  gem.homepage      = ""
+
+  gem.add_dependency 'nokogiri'
+  gem.add_dependency 'rubyzip'
+
+  gem.add_development_dependency 'pry'
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/test/shared_strings.xml

@@ -0,0 +1,80 @@
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="6" uniqueCount="5">
+    <si>
+        <t>Cell A1</t>
+    </si>
+    <si>
+        <t>Cell B1</t>
+    </si>
+    <si>
+        <t>My Cell</t>
+    </si>
+    <si>
+        <r>
+            <rPr>
+                <sz val="11"/>
+                <color rgb="FFFF0000"/>
+                <rFont val="Calibri"/>
+                <family val="2"/>
+                <scheme val="minor"/>
+            </rPr>
+            <t>Cell</t>
+        </r>
+        <r>
+            <rPr>
+                <sz val="11"/>
+                <color theme="1"/>
+                <rFont val="Calibri"/>
+                <family val="2"/>
+                <scheme val="minor"/>
+            </rPr>
+            <t xml:space="preserve"> </t>
+        </r>
+        <r>
+            <rPr>
+                <b/>
+                <sz val="11"/>
+                <color theme="1"/>
+                <rFont val="Calibri"/>
+                <family val="2"/>
+                <scheme val="minor"/>
+            </rPr>
+            <t>A2</t>
+        </r>
+    </si>
+    <si>
+        <r>
+            <rPr>
+                <sz val="11"/>
+                <color rgb="FF00B0F0"/>
+                <rFont val="Calibri"/>
+                <family val="2"/>
+                <scheme val="minor"/>
+            </rPr>
+            <t>Cell</t>
+        </r>
+        <r>
+            <rPr>
+                <sz val="11"/>
+                <color theme="1"/>
+                <rFont val="Calibri"/>
+                <family val="2"/>
+                <scheme val="minor"/>
+            </rPr>
+            <t xml:space="preserve"> </t>
+        </r>
+        <r>
+            <rPr>
+                <i/>
+                <sz val="11"/>
+                <color theme="1"/>
+                <rFont val="Calibri"/>
+                <family val="2"/>
+                <scheme val="minor"/>
+            </rPr>
+            <t>B2</t>
+        </r>
+    </si>
+    <si>
+        <t>Cell Fmt</t>
+    </si>
+</sst>

data/test/simple_xlsx_reader_test.rb

@@ -0,0 +1,108 @@
+require_relative 'test_helper'
+require 'time'
+
+describe SimpleXlsxReader do
+  let(:sesame_street_blog_file) { File.join(File.dirname(__FILE__),
+                                            'sesame_street_blog.xlsx') }
+
+  let(:subject) { SimpleXlsxReader::Document.new(sesame_street_blog_file) }
+
+  describe '#to_hash' do
+    it 'reads an xlsx file into a hash of {[sheet name] => [data]}' do
+      subject.to_hash.must_equal({
+        "Authors"=>
+          [["Name", "Occupation"],
+           ["Big Bird", "Teacher"]],
+
+        "Posts"=>
+          [["Author Name", "Title", "Body", "Created At", "Comment Count"],
+           ["Big Bird", "The Number 1", "The Greatest", Time.parse("2002-01-01 11:00:00 UTC"), 1],
+           ["Big Bird", "The Number 2", "Second Best", Time.parse("2002-01-02 14:00:00 UTC"), 2]]
+      })
+    end
+  end
+
+  describe SimpleXlsxReader::Document::Mapper do
+    let(:described_class) { SimpleXlsxReader::Document::Mapper }
+
+    describe '::cast' do
+      it 'reads type s as a shared string' do
+        described_class.cast('1', 's', shared_strings: ['a', 'b', 'c']).
+          must_equal 'b'
+      end
+
+      it 'reads type inlineStr as a string' do
+        xml = Nokogiri::XML(%( <c t="inlineStr"><is><t>the value</t></is></c> ))
+        described_class.cast(xml.text, 'inlineStr').must_equal 'the value'
+      end
+    end
+
+    describe '#shared_strings' do
+      let(:xml) do
+        SimpleXlsxReader::Document::Xml.new.tap do |xml|
+          xml.shared_strings = Nokogiri::XML(File.read(
+            File.join(File.dirname(__FILE__), 'shared_strings.xml') ))
+        end
+      end
+
+      subject { described_class.new(xml) }
+
+      it 'parses strings formatted at the cell level' do
+        subject.shared_strings[0..2].must_equal ['Cell A1', 'Cell B1', 'My Cell']
+      end
+
+      it 'parses strings formatted at the character level' do
+        subject.shared_strings[3..5].must_equal ['Cell A2', 'Cell B2', 'Cell Fmt']
+      end
+    end
+
+    describe "parse errors" do
+      after do
+        SimpleXlsxReader.configuration.catch_cell_load_errors = false
+      end
+
+      let(:xml) do
+        SimpleXlsxReader::Document::Xml.new.tap do |xml|
+          xml.sheets = [Nokogiri::XML(
+            <<-XML
+            <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+              <sheetData>
+                <row>
+                  <c s='0'>
+                    <v>14 is a date style; this is not a date</v>
+                  </c>
+                </row>
+              </sheetData>
+            </worksheet>
+            XML
+          )]
+
+          # s='0' above refers to the value of numFmtId at cellXfs index 0
+          xml.styles = Nokogiri::XML(
+            <<-XML
+            <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+              <cellXfs count="1">
+                <xf numFmtId="14" />
+              </cellXfs>
+            </styleSheet>
+            XML
+          )
+        end
+      end
+
+      it 'raises if configuration.raise_on_parse_error' do
+        SimpleXlsxReader.configuration.catch_cell_load_errors = false
+
+        lambda { described_class.new(xml).parse_sheet('test', xml.sheets.first) }.
+          must_raise(SimpleXlsxReader::CellLoadError)
+      end
+
+      it 'records a load error if not configuration.raise_on_parse_error' do
+        SimpleXlsxReader.configuration.catch_cell_load_errors = true
+
+        sheet = described_class.new(xml).parse_sheet('test', xml.sheets.first)
+        sheet.load_errors[[0,0]].must_include 'invalid value for Integer'
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+gem 'minitest'
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'pry'
+
+$:.unshift File.expand_path("lib")
+require 'simple_xlsx_reader'

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: simple_xlsx_reader
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Woody Peterson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Read xlsx data the Ruby way
+email:
+- woody@sigby.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/simple_xlsx_reader.rb
+- lib/simple_xlsx_reader/version.rb
+- simple_xlsx_reader.gemspec
+- test/sesame_street_blog.xlsx
+- test/shared_strings.xml
+- test/simple_xlsx_reader_test.rb
+- test/test_helper.rb
+homepage: ''
+licenses: []
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Read xlsx data the Ruby way
+test_files:
+- test/sesame_street_blog.xlsx
+- test/shared_strings.xml
+- test/simple_xlsx_reader_test.rb
+- test/test_helper.rb
+has_rdoc: