simple_xlsx_reader 2.0.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 979490ce3bd7f0482879fb5fb5465e10ad1b07c1488d0a544950131d9063050a
-  data.tar.gz: 412d0040a586cc5ee4acdd4a2f74dd74f3bf9eb781a35d8a36c12f6caadc566c
+  metadata.gz: 8552d34f153cbdc6561c40725488d193e9aa48debcded0af24d32daf01b2f951
+  data.tar.gz: 2a0fecdec3698bb16717244fc7bf9b45b4fe0f6b216038e9823f9a5fea2ea8fa
 SHA512:
-  metadata.gz: 00c01bc0c2a393eb35e458411dfeab55b8bf30cee2661324cbd97a175baf0ceb31a881b1b2b7bd668a2b475ff008372c1428908340e30769308884355fdd46e8
-  data.tar.gz: 81b1b26806a97c56710cab64aa22212985dea82b308e2fbba6835f4ea7a69b79067268bb13537999594dc5722928f1df235938355a7d4a51b58ae7ed4af1d093
+  metadata.gz: 77f99e8ad1020f0313171dcd0b14f7200fdf116e16de312146eb66a4d9347e94a0bf1cb4483f606975cd8bc776e80995473485271e05ee0a11136ef72cdeeae5
+  data.tar.gz: 7ee3ed8c37df6632981bd6eeb301de5f852df0f66534ce91593923cf1b51aa1dc0b07aed224d5d88cbd4b1f8a6901fdb17164e6e9f22fb10d4e5d90a3c24f437

data/.github/workflows/ruby.yml

@@ -22,15 +22,12 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby-version: ['2.6', '2.7', '3.0']
+        ruby-version: ['2.6', '2.7', '3.0', '3.1', '3.2']
 
     steps:
     - uses: actions/checkout@v3
     - name: Set up Ruby
-    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
-    # change this to (see https://github.com/ruby/setup-ruby#versioning):
-    # uses: ruby/setup-ruby@v1
-      uses: ruby/setup-ruby@2b019609e2b0f1ea1a2bc8ca11cb82ab46ada124
+      uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby-version }}
         bundler-cache: true # runs 'bundle install' and caches installed gems automatically

data/CHANGELOG.md

@@ -1,3 +1,52 @@
+### 5.0.0
+
+* Change SimpleXlsxReader::Hyperlink to default to the visible cell value
+  instead of the hyperlink URL, which in the case of mailto hyperlinks is
+  surprising.
+* Fix blank content when parsing docs from string (@codemole)
+
+### 4.0.1
+
+* Fix nil error when handling some inline strings
+
+  Inline strings are almost exclusively used by non-Excel XLSX
+  implementations, but are valid, and sometimes have nil chunks.
+
+  Also, inline strings weren't preserving whitespace if Nokogiri is
+  parsing the string in chunks, as it does when encountering escaped
+  characters. Fixed.
+
+### 4.0.0
+
+* Fix percentage rounding errors. Previously we were dividing by 100, when we
+  actually don't need to, so percentage types were 100x too small. Fixes #21.
+  Major bump because workarounds might have been implemented for previous
+  incorrect behavior.
+* Fix small oddity in one currency format where round numbers would be cast
+  to an integer instead of a float.
+
+### 3.0.1
+
+* Fix parsing "chunky" UTF-8 workbooks. Closes issues #39 and #45. See ce67f0d4.
+
+### 3.0.0
+
+* Change the way we typecast cells in the General format. This probably won't
+  break anything in your app, but it's a change in behavior that theoretically
+  could.
+
+  Previously, we were treating cells using General the format as strings, when
+  according to the Office XML standard, they should be treated as numbers. We
+  now attempt to cast such cells as numbers, and fall back to strings if number
+  casting fails.
+
+  Thanks @jrodrigosm
+
+### 2.0.1
+
+* Restore ability to parse IO strings (@robbevp)
+* Add Ruby 3.1 and 3.2 to CI (@taichi-ishitani)
+
 ### 2.0.0
 
 * SPEED

data/README.md

@@ -9,15 +9,17 @@ then forgotten. We just want to get the data, and get out!
 
 ## Summary (now with stream parsing):
 
-    doc = SimpleXlsxReader.open('/path/to/workbook.xlsx')
-    doc.sheets # => [<#SXR::Sheet>, ...]
-    doc.sheets.first.name # 'Sheet1'
-    doc.sheets.first.rows # <SXR::Document::RowsProxy>
-    doc.sheets.first.rows.each # an <Enumerator> ready to chain or stream
-    doc.sheets.first.rows.each {} # Streams the rows to your block
-    doc.sheets.first.rows.each(headers: true) {} # Streams row-hashes
-    doc.sheets.first.rows.each(headers: {id: /ID/}) {} # finds & maps headers, streams
-    doc.sheets.first.rows.slurp # Slurps rows into memory as a 2D array
+```ruby
+doc = SimpleXlsxReader.open('/path/to/workbook.xlsx')
+doc.sheets # => [<#SXR::Sheet>, ...]
+doc.sheets.first.name # 'Sheet1'
+rows = doc.sheet.first.rows # <SXR::Document::RowsProxy>
+rows.each # an <Enumerator> ready to chain or stream
+rows.each {} # Streams the rows to your block
+rows.each(headers: true) {} # Streams row-hashes
+rows.each(headers: {id: /ID/}) {} # finds & maps headers, streams
+rows.slurp # Slurps rows into memory as a 2D array
+```
 
 That's the gist of it!
 
@@ -29,7 +31,8 @@ See also the [Document](https://github.com/woahdae/simple_xlsx_reader/blob/2.0.0
 
 This project was started years ago, primarily because other Ruby xlsx parsers
 didn't import data with the correct types. Numbers as strings, dates as numbers,
-hyperlinks with inaccessible URLs, or - subtly buggy - simple dates as DateTime
+[hyperlinks](https://github.com/woahdae/simple_xlsx_reader/blob/master/lib/simple_xlsx_reader/hyperlink.rb)
+with inaccessible URLs, or - subtly buggy - simple dates as DateTime
 objects. If your app uses a timezone offset, depending on what timezone and
 what time of day you load the xlsx file, your dates might end up a day off!
 SimpleXlsxReader understands all these correctly.
@@ -39,12 +42,14 @@ SimpleXlsxReader understands all these correctly.
 Many Ruby xlsx parsers seem to be inspired more by Excel than Ruby, frankly.
 SimpleXlsxReader strives to be fairly idiomatic Ruby:
 
-    # quick example having fun w/ ruby
-    doc = SimpleXlsxReader.open(path_or_io)
-    doc.sheets.first.rows.each(headers: {id: /ID/})
-      .with_index.with_object({}) do |(row, index), acc|
-        acc[row[:id]] = index
-      end
+```ruby
+# quick example having fun w/ ruby
+doc = SimpleXlsxReader.open(path_or_io)
+doc.sheets.first.rows.each(headers: {id: /ID/})
+  .with_index.with_object({}) do |(row, index), acc|
+    acc[row[:id]] = index
+end
+```
 
 ### Now faster
 
@@ -77,15 +82,19 @@ If you had an excel sheet representing this data:
 
 Get a handle on the rows proxy:
 
-`rows = SimpleXlsxReader.open('suited_heroes.xlsx').sheets.first.rows`
+```ruby
+rows = SimpleXlsxReader.open('suited_heroes.xlsx').sheets.first.rows
+```
 
 Simple streaming (kinda boring):
 
-`rows.each { |row| ... }`
+```ruby
+rows.each { |row| ... }
+````
 
 Streaming with headers, and how about a little enumerable chaining:
 
-```
+```ruby
 # Map of hero names by ID: { 117 => 'John Halo', ... }
 
 rows.each(headers: true).with_object({}) do |row, acc|
@@ -108,7 +117,7 @@ Sometimes though you have some junk at the top of your spreadsheet:
 For this, `headers` can be a hash whose keys replace headers and whose values
 help find the correct header row:
 
-```
+```ruby
 # Same map of hero names by ID: { 117 => 'John Halo', ... }
 
 rows.each(headers: {id: /ID/, name: /Name/}).with_object({}) do |row, acc|
@@ -119,7 +128,7 @@ end
 If your header-to-attribute mapping is more complicated than key/value, you
 can do the mapping elsewhere, but use a block to find the header row:
 
-```
+```ruby
 # Example roughly analogous to some production code mapping a single spreadsheet
 # across many objects. Might be a simpler way now that we have the headers-hash
 # feature.
@@ -168,9 +177,11 @@ can set `SimpleXlsxReader.configuration.catch_cell_load_errors =
 true`, and load errors will instead be inserted into Sheet#load_errors keyed
 by [rownum, colnum]:
 
-    {
-      [rownum, colnum] => '[error]'
-    }
+```ruby
+{
+  [rownum, colnum] => '[error]'
+}
+```
 
 ### Performance
 
@@ -233,11 +244,9 @@ This project follows [semantic versioning 1.0](http://semver.org/spec/v1.0.0.htm
 Remember to write tests, think about edge cases, and run the existing
 suite.
 
-Note that as of commit 665cbafdde, the most extreme end of the
-linear-time performance test, which is 10,000 rows (12 columns), runs in
-~4 seconds on Ruby 2.1 on a 2012 MBP. If the linear time assertion fails
-or you're way off that, there is probably a performance regression in
-your code.
+The full suite contains a performance test that on an M1 MBP runs the final
+large file in about five seconds. Check out that test before & after your
+change to check for performance changes.
 
 Then, the standard stuff:
 

data/lib/simple_xlsx_reader/document.rb

@@ -8,14 +8,16 @@ module SimpleXlsxReader
   # Main class for the public API. See the README for usage examples,
   # or read the code, it's pretty friendly.
   class Document
-    attr_reader :file_path
+    attr_reader :string_or_io
 
-    def initialize(file_path)
-      @file_path = file_path
+    def initialize(legacy_file_path = nil, file_path: nil, string_or_io: nil)
+      fail(ArgumentError, 'either file_path or string_or_io must be provided') if legacy_file_path.nil? && file_path.nil? && string_or_io.nil?
+  
+      @string_or_io = string_or_io || File.new(legacy_file_path || file_path)
     end
 
     def sheets
-      @sheets ||= Loader.new(file_path).init_sheets
+      @sheets ||= Loader.new(string_or_io).init_sheets
     end
 
     # Expensive because it slurps all the sheets into memory,

data/lib/simple_xlsx_reader/hyperlink.rb

@@ -4,27 +4,26 @@ module SimpleXlsxReader
   # We support hyperlinks as a "type" even though they're technically
   # represented either as a function or an external reference in the xlsx spec.
   #
-  # Since having hyperlink data in our sheet usually means we might want to do
-  # something primarily with the URL (store it in the database, download it, etc),
-  # we go through extra effort to parse the function or follow the reference
-  # to represent the hyperlink primarily as a URL. However, maybe we do want
-  # the hyperlink "friendly name" part (as MS calls it), so here we've subclassed
-  # string to tack on the friendly name. This means 80% of us that just want
-  # the URL value will have to do nothing extra, but the 20% that might want the
-  # friendly name can access it.
+  # In practice, hyperlinks are usually a link or a mailto. In the case of a
+  # link, we probably want to follow it to download something, but in the case
+  # of an email, we probably just want the email and not the mailto. So we
+  # represent a hyperlink primarily as it is seen by the user, following the
+  # principle of least surprise, but the url is accessible via #url.
   #
-  # Note, by default, the value we would get by just asking the cell would
-  # be the "friendly name" and *not* the URL, which is tucked away in the
-  # function definition or a separate "relationships" meta-document.
+  # Microsoft calls the visible part of a hyperlink cell the "friendly name,"
+  # so we expose that as a method too, in case you want to be explicit about
+  # how you're accessing it.
   #
   # See MS documentation on the HYPERLINK function for some background:
   # https://support.office.com/en-us/article/HYPERLINK-function-333c7ce6-c5ae-4164-9c47-7de9b76f577f
   class Hyperlink < String
     attr_reader :friendly_name
+    attr_reader :url
 
     def initialize(url, friendly_name = nil)
       @friendly_name = friendly_name
-      super(url)
+      @url = url
+      super(friendly_name || url)
     end
   end
 end

data/lib/simple_xlsx_reader/loader/sheet_parser.rb

@@ -31,10 +31,9 @@ module SimpleXlsxReader
         @url = nil # silence warnings
         @function = nil # silence warnings
         @capture = nil # silence warnings
+        @captured = nil # silence warnings
         @dimension = nil # silence warnings
 
-        @file_io.rewind # in case we've already parsed this once
-
         # In this project this is only used for GUI-made hyperlinks (as opposed
         # to FUNCTION-based hyperlinks). Unfortunately the're needed to parse
         # the spreadsheet, and they come AFTER the sheet data. So, solution is
@@ -44,9 +43,10 @@ module SimpleXlsxReader
         if xrels_file&.grep(/hyperlink/)&.any?
           xrels_file.rewind
           load_gui_hyperlinks # represented as hyperlinks_by_cell
-          @file_io.rewind
         end
 
+        @file_io.rewind # in case we've already parsed this once
+
         Nokogiri::XML::SAX::Parser.new(self).parse(@file_io)
       end
 
@@ -77,10 +77,10 @@ module SimpleXlsxReader
 
         return unless @capture
 
-        @current_row[cell_idx] =
+        captured =
           begin
             SimpleXlsxReader::Loader.cast(
-              string.strip, @type, @style,
+              string, @type, @style,
               url: @url || hyperlinks_by_cell&.[](@cell_name),
               shared_strings: shared_strings,
               base_date: base_date
@@ -99,9 +99,19 @@ module SimpleXlsxReader
             else
               @load_errors[[row_idx, col_idx]] = e.message
 
-              string.strip
+              string
             end
           end
+
+        # For some reason I can't figure out in a reasonable timeframe,
+        # SAX parsing some workbooks captures separate strings in the same cell
+        # when we encounter UTF-8, although I can't get workbooks made in my
+        # own version of excel to repro it. Our fix is just to keep building
+        # the string in this case, although maybe there's a setting in Nokogiri
+        # to make it not do this (looked, couldn't find it).
+        #
+        # Loading the workbook test/chunky_utf8.xlsx repros the issue.
+        @captured = @captured ? @captured + (captured || '') : captured
       end
 
       def end_element(name)
@@ -134,7 +144,10 @@ module SimpleXlsxReader
           # isn't the most robust strategy, but it likely fits 99% of use cases
           # considering it's not a problem with actual excel docs.
           @dimension = "A1:#{@cell_name}" if @dimension.nil?
-        when 'v', 't' then @capture = false
+        when 'v', 't'
+          @current_row[cell_idx] = @captured
+          @capture = false
+          @captured = nil
         when 'f' then @function = false
         when 'c' then @url = nil
         end

data/lib/simple_xlsx_reader/loader/style_types_parser.rb

@@ -9,38 +9,39 @@ module SimpleXlsxReader
 
       # 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     # @
+        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)
+        44 => :float,        # some odd currency format ?from Office 2007?
+        45 => :time,         # mm:ss
+        46 => :time,         # [h]:mm:ss
+        47 => :time,         # mmss.0
+        48 => :bignum,       # ##0.0E+0
+        49 => :unsupported   # @
       }.freeze
 
       def parse

data/lib/simple_xlsx_reader/loader.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 module SimpleXlsxReader
-  class Loader < Struct.new(:file_path)
+  class Loader < Struct.new(:string_or_io)
     attr_accessor :shared_strings, :sheet_parsers, :sheet_toc, :style_types, :base_date
 
     def init_sheets
       ZipReader.new(
-        file_path: file_path,
+        string_or_io: string_or_io,
         loader: self
       ).read
 
@@ -19,12 +19,12 @@ module SimpleXlsxReader
       end
     end
 
-    ZipReader = Struct.new(:file_path, :loader, keyword_init: true) do
+    ZipReader = Struct.new(:string_or_io, :loader, keyword_init: true) do
       attr_reader :zip
 
       def initialize(*args)
         super
-        @zip = SimpleXlsxReader::Zip.open(file_path)
+        @zip = SimpleXlsxReader::Zip.open_buffer(string_or_io)
       end
 
       def read
@@ -149,14 +149,20 @@ module SimpleXlsxReader
         # detected earlier and cast here by its standardized symbol
         ##
 
-        when :string, :unsupported
+        # no type encoded with the the General format defaults to a number type
+        when nil, :string
+          retval = Integer(value, exception: false)
+          retval ||= Float(value, exception: false)
+          retval ||= value
+          retval
+        when :unsupported
           value
         when :fixnum
           value.to_i
         when :float
           value.to_f
         when :percentage
-          value.to_f / 100
+          value.to_f
         # the trickiest. note that  all these formats can vary on
         # whether they actually contain a date, time, or datetime.
         when :date, :time, :date_time

data/lib/simple_xlsx_reader/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SimpleXlsxReader
-  VERSION = '2.0.0'
+  VERSION = '5.0.0'
 end

data/lib/simple_xlsx_reader.rb

@@ -42,8 +42,11 @@ module SimpleXlsxReader
     end
 
     def open(file_path)
-      Document.new(file_path).tap(&:sheets)
+      Document.new(file_path: file_path).tap(&:sheets)
+    end
+    
+    def parse(string_or_io)
+      Document.new(string_or_io: string_or_io).tap(&:sheets)
     end
-    alias parse open
   end
 end

data/test/performance_test.rb

@@ -70,7 +70,7 @@ describe 'SimpleXlsxReader Benchmark' do
   let(:styles) do
     # s='0' above refers to the value of numFmtId at cellXfs index 0,
     # which is in this case 'General' type
-    styles =
+    _styles =
       <<-XML
         <styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
           <cellXfs count="1">

data/test/simple_xlsx_reader_test.rb

@@ -18,6 +18,7 @@ describe SimpleXlsxReader do
 
   let(:sesame_street_blog_file_path) { File.join(File.dirname(__FILE__), 'sesame_street_blog.xlsx') }
   let(:sesame_street_blog_io) { File.new(sesame_street_blog_file_path) }
+  let(:sesame_street_blog_string) { IO.read(sesame_street_blog_file_path) }
 
   let(:expected_result) do
     {
@@ -54,6 +55,14 @@ describe SimpleXlsxReader do
       end
     end
 
+    describe 'load from string' do
+      let(:subject) { SimpleXlsxReader.parse(sesame_street_blog_io) }
+
+      it 'reads an xlsx string into a hash of {[sheet name] => [data]}' do
+        _(subject.to_hash).must_equal(expected_result)
+      end
+    end
+
     it 'outputs strings in UTF-8 encoding' do
       document = SimpleXlsxReader.parse(sesame_street_blog_io)
       _(document.sheets[0].rows.to_a.flatten.map(&:encoding).uniq)
@@ -83,7 +92,7 @@ describe SimpleXlsxReader do
         body: 'The Greatest',
         created_at: Time.parse('2002-01-01 11:00:00 UTC'),
         count: 1,
-        "URL" => 'http://www.example.com/hyperlink-function'
+        "URL" => 'This uses the HYPERLINK() function'
       )
 
       _(rows.slurped?).must_equal false
@@ -113,6 +122,52 @@ describe SimpleXlsxReader do
 
   let(:reader) { SimpleXlsxReader.open(xlsx.archive.path) }
 
+  describe 'when parsing escaped characters' do
+    let(:escaped_content) do
+      '<a href="https://www.example.com">Link A</a> • <a href="https://www.example.com">Link B</a>'
+    end
+
+    let(:unescaped_content) do
+      '<a href="https://www.example.com">Link A</a> &bull; <a href="https://www.example.com">Link B</a>'
+    end
+
+    let(:sheet) do
+      <<~XML
+        <worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+          <dimension ref="A1:B1" />
+          <sheetData>
+            <row r="1">
+              <c r="A1" s="1" t="s">
+                <v>0</v>
+              </c>
+              <c r='B1' s='0'>
+                <v>#{escaped_content}</v>
+              </c>
+            </row>
+          </sheetData>
+        </worksheet>
+      XML
+    end
+
+    let(:shared_strings) do
+      <<~XML
+        <sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" count="1" uniqueCount="1">
+          <si>
+            <t>#{escaped_content}</t>
+          </si>
+        </sst>
+      XML
+    end
+
+    it 'loads correctly using inline strings' do
+      _(reader.sheets[0].rows.slurp[0][0]).must_equal(unescaped_content)
+    end
+
+    it 'loads correctly using shared strings' do
+      _(reader.sheets[0].rows.slurp[0][1]).must_equal(unescaped_content)
+    end
+  end
+
   describe 'Sheet#rows#each(headers: true)' do
     let(:sheet) do
       <<~XML
@@ -818,6 +873,10 @@ describe SimpleXlsxReader do
                 <c r='I1' s='0'>
                   <v>GUI-made hyperlink</v>
                 </c>
+
+                <c r='J1' s='0'>
+                  <v>1</v>
+                </c>
               </row>
             </sheetData>
 
@@ -916,6 +975,10 @@ describe SimpleXlsxReader do
         )
       )
     end
+
+    it "reads 'Generic' cells with numbers as numbers" do
+      _(@row[9]).must_equal 1
+    end
   end
 
   describe 'parsing documents with blank rows' do
@@ -927,7 +990,7 @@ describe SimpleXlsxReader do
             <sheetData>
             <row r="2" spans="1:1">
               <c r="A2" s="0">
-                <v>0</v>
+                <v>a</v>
               </c>
             </row>
             <row r="4" spans="1:1">
@@ -958,13 +1021,107 @@ describe SimpleXlsxReader do
     it 'reads row data despite gaps in row numbering' do
       _(@rows).must_equal [
         [nil, nil, nil, nil],
-        ['0', nil, nil, nil],
+        ['a', nil, nil, nil],
         [nil, nil, nil, nil],
-        [nil, '1', nil, nil],
-        [nil, nil, '2', nil],
+        [nil, 1, nil, nil],
+        [nil, nil, 2, nil],
         [nil, nil, nil, nil],
-        [nil, nil, nil, '3']
+        [nil, nil, nil, 3]
+      ]
+    end
+  end
+
+  describe 'parsing documents with non-hyperlinked rels' do
+    let(:rels) do
+      [
+        Nokogiri::XML(
+          <<-XML
+          <?xml version="1.0" encoding="UTF-8"?>
+          <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"></Relationships>
+          XML
+        ).remove_namespaces!
       ]
     end
+
+    describe 'when document is opened as path' do
+      before do
+        @row = SimpleXlsxReader.open(xlsx.archive.path).sheets[0].rows.to_a[0]
+      end
+
+      it 'reads cell content' do
+        _(@row[0]).must_equal 'Cell A'
+      end
+    end
+
+    describe 'when document is parsed as a String' do
+      before do
+        output = File.binread(xlsx.archive.path)
+        @row = SimpleXlsxReader.parse(output).sheets[0].rows.to_a[0]
+      end
+
+      it 'reads cell content' do
+        _(@row[0]).must_equal 'Cell A'
+      end
+    end
+
+    describe 'when document is parsed as StringIO' do
+      before do
+        stream = StringIO.new(File.binread(xlsx.archive.path), 'rb')
+        @row = SimpleXlsxReader.parse(stream).sheets[0].rows.to_a[0]
+        stream.close
+      end
+
+      it 'reads cell content' do
+        _(@row[0]).must_equal 'Cell A'
+      end
+    end
+  end
+
+  # https://support.microsoft.com/en-us/office/available-number-formats-in-excel-0afe8f52-97db-41f1-b972-4b46e9f1e8d2
+  describe 'numeric fields styled as "General"' do
+    let(:misc_numbers_path) do
+      File.join(File.dirname(__FILE__), 'misc_numbers.xlsx')
+    end
+
+    let(:sheet) { SimpleXlsxReader.open(misc_numbers_path).sheets[0] }
+
+    it 'reads medium sized integers as integers' do
+      _(sheet.rows.slurp[1][0]).must_equal 98070
+    end
+
+    it 'reads large (>12 char) integers as integers' do
+      _(sheet.rows.slurp[1][1]).must_equal 1234567890123
+    end
+  end
+
+  describe 'with mysteriously chunky UTF-8 text' do
+    let(:chunky_utf8_path) do
+      File.join(File.dirname(__FILE__), 'chunky_utf8.xlsx')
+    end
+
+    let(:sheet) { SimpleXlsxReader.open(chunky_utf8_path).sheets[0] }
+
+    it 'reads the whole cell text' do
+      _(sheet.rows.slurp[1]).must_equal(
+        ["sample-company-1", "Korntal-Münchingen", "Bronholmer straße"]
+      )
+    end
+  end
+
+  describe 'when using percentages & currencies' do
+    let(:pnc_path) do
+      # This file provided by a GitHub user having parse errors in these fields
+      File.join(File.dirname(__FILE__), 'percentages_n_currencies.xlsx')
+    end
+
+    let(:sheet) { SimpleXlsxReader.open(pnc_path).sheets[0] }
+
+    it 'reads percentages as floats of the form 0.XX' do
+      _(sheet.rows.slurp[1][2]).must_equal(0.87)
+    end
+
+    it 'reads currencies as floats' do
+      _(sheet.rows.slurp[1][4]).must_equal(300.0)
+    end
   end
 end

data/test/test_xlsx_builder.rb

@@ -57,7 +57,6 @@ TestXlsxBuilder = Struct.new(:shared_strings, :styles, :sheets, :workbook, :rels
     self.styles ||= DEFAULTS[:styles]
     self.sheets ||= [DEFAULTS[:sheet]]
     self.rels ||= []
-    self.shared_strings ||= []
   end
 
   def archive
@@ -76,7 +75,7 @@ TestXlsxBuilder = Struct.new(:shared_strings, :styles, :sheets, :workbook, :rels
         styles_file.write(styles)
       end
 
-      if shared_strings.any?
+      if shared_strings
         zip.get_output_stream('xl/sharedStrings.xml') do |ss_file|
           ss_file.write(shared_strings)
         end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_xlsx_reader
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Woody Peterson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-18 00:00:00.000000000 Z
+date: 2023-06-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -105,6 +105,7 @@ files:
 - lib/simple_xlsx_reader/loader/workbook_parser.rb
 - lib/simple_xlsx_reader/version.rb
 - simple_xlsx_reader.gemspec
+- test/chunky_utf8.xlsx
 - test/date1904.xlsx
 - test/date1904_test.rb
 - test/datetime_test.rb
@@ -113,6 +114,8 @@ files:
 - test/gdocs_sheet_test.rb
 - test/lower_case_sharedstrings.xlsx
 - test/lower_case_sharedstrings_test.rb
+- test/misc_numbers.xlsx
+- test/percentages_n_currencies.xlsx
 - test/performance_test.rb
 - test/sesame_street_blog.xlsx
 - test/shared_strings.xml
@@ -144,6 +147,7 @@ signing_key:
 specification_version: 4
 summary: Read xlsx data the Ruby way
 test_files:
+- test/chunky_utf8.xlsx
 - test/date1904.xlsx
 - test/date1904_test.rb
 - test/datetime_test.rb
@@ -152,6 +156,8 @@ test_files:
 - test/gdocs_sheet_test.rb
 - test/lower_case_sharedstrings.xlsx
 - test/lower_case_sharedstrings_test.rb
+- test/misc_numbers.xlsx
+- test/percentages_n_currencies.xlsx
 - test/performance_test.rb
 - test/sesame_street_blog.xlsx
 - test/shared_strings.xml