roo-calamine 0.0.1

data/lib/roo/calamine/context.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Roo
+  module Calamine
+    # The answers the native reader needs from roo while it builds cells. Each
+    # one comes from the roo object or method that SheetDoc#cell_from_xml uses,
+    # so formats, shared strings, and errors are roo's own.
+    class Context
+      attr_reader :hyperlinks, :empty_cell
+
+      def initialize(shared, hyperlinks, empty_cell)
+        @shared = shared
+        @hyperlinks = hyperlinks
+        @empty_cell = empty_cell
+      end
+
+      def base_date
+        @shared.base_date
+      end
+
+      def base_timestamp
+        @shared.base_timestamp
+      end
+
+      def style(index)
+        format = @shared.styles.style_format(index)
+        [format.to_s, Roo::Excelx::Format.to_type(format)]
+      end
+
+      def style_index(text)
+        text.to_i
+      end
+
+      def coordinate(reference)
+        Roo::Utils.extract_coordinate(reference)
+      end
+
+      # roo's own memoized shared-string arrays: plain text, and the HTML that
+      # SharedStrings#use_html? tests (nil when the HTML wrapper is disabled).
+      def shared_strings
+        strings = @shared.shared_strings
+        html_disabled = strings.instance_variable_get(:@options)[:disable_html_wrapper]
+        [strings.to_a, (strings.to_html unless html_disabled)]
+      end
+
+      def shared_string(text)
+        shared_string_at(@shared.shared_strings, text.to_i)
+      end
+
+      private
+
+      def shared_string_at(strings, index)
+        strings.use_html?(index) ? strings.to_html[index] : strings[index]
+      end
+    end
+  end
+end

data/lib/roo/calamine/sheet_doc.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Roo
+  module Calamine
+    # Prepended to Roo::Excelx::SheetDoc, where every worksheet read in roo
+    # starts: Sheet#cells (and with it #cell, #row, #each, #parse) and
+    # Sheet#each_row (#each_row_streaming). Everything else, including roo's
+    # padding, offset, and row limits, stays roo's code.
+    module SheetDoc
+      # Cells the native reader parses ahead of Ruby, per batch.
+      BATCH_CELLS = 16_384
+
+      def cells(relationships)
+        return super if @cells || !native?
+
+        cells = {}
+        reader = Native::Reader.new(@path, false, BATCH_CELLS)
+        converter = Native::Converter.new(Context.new(@shared, hyperlinks(relationships), @options[:empty_cell]), false)
+        nil while reader.fill_cells(cells, converter)
+        expand_merged_ranges(cells) if @options[:expand_merged_ranges]
+        @cells = cells
+      rescue UnsupportedError
+        super
+      ensure
+        reader&.close
+      end
+
+      # Yields Native::Row objects; #each_cell turns one into cells when roo
+      # asks for it, so rows roo skips are never converted, as in roo.
+      def each_row_streaming(&)
+        return super unless native?
+
+        yielded = 0
+        reader = Native::Reader.new(@path, true, BATCH_CELLS)
+        while (rows = reader.next_rows)
+          rows.each do |row|
+            yield row
+            yielded += 1
+          end
+        end
+        nil
+      rescue UnsupportedError
+        # roo reads the sheet again; skip the rows already yielded.
+        skip = yielded
+        super { |row| skip.zero? ? yield(row) : skip -= 1 }
+      ensure
+        # Also when the caller stops early, as roo does for max_rows.
+        reader&.close
+      end
+
+      def each_cell(row_xml, &)
+        return super unless row_xml.is_a?(Native::Row)
+
+        @calamine_stream_converter ||= Native::Converter.new(Context.new(@shared, hyperlinks(@relationships), true),
+                                                             true)
+        @calamine_stream_converter.row_cells(row_xml).each(&)
+      end
+
+      private
+
+      def native?
+        @path && Calamine.enabled?
+      end
+    end
+  end
+end

data/lib/roo/calamine/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Roo
+  module Calamine
+    VERSION = "0.0.1"
+  end
+end

data/lib/roo/calamine.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "roo"
+require "roo/excelx"
+require_relative "calamine/version"
+
+module Roo
+  # Reads `.xlsx` and `.xlsm` worksheets for Roo::Excelx with a native
+  # extension. Loading this file is all it takes; `Roo::Calamine.enabled =
+  # false` or `ROO_CALAMINE=0` switches back to roo's own reader at runtime.
+  module Calamine
+    # Raised by the native reader for XML it does not reproduce exactly the
+    # way roo reads it. Roo::Calamine rescues it and lets roo read the sheet.
+    class UnsupportedError < StandardError; end
+
+    DISABLING_ENV_VALUES = %w[0 false off].freeze
+    private_constant :DISABLING_ENV_VALUES
+
+    @enabled = true
+
+    class << self
+      attr_writer :enabled
+
+      # Whether the native extension is loaded. It is `false` on Ruby
+      # implementations other than CRuby, such as JRuby.
+      def available?
+        defined?(Native::Reader) ? true : false
+      end
+
+      # Whether the next worksheet read goes through the native reader.
+      def enabled?
+        @enabled && available? && !DISABLING_ENV_VALUES.include?(ENV.fetch("ROO_CALAMINE", "").downcase)
+      end
+    end
+  end
+end
+
+if RUBY_ENGINE == "ruby"
+  begin
+    require "roo/calamine/#{RUBY_VERSION[/\d+\.\d+/]}/roo_calamine"
+  rescue LoadError
+    require "roo/calamine/roo_calamine"
+  end
+  require_relative "calamine/context"
+  require_relative "calamine/sheet_doc"
+  Roo::Excelx::SheetDoc.prepend(Roo::Calamine::SheetDoc)
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: roo-calamine
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Sebastian Sala
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rb_sys
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.130
+- !ruby/object:Gem::Dependency
+  name: roo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: Unofficial plugin for roo. Add it to the Gemfile and Roo::Excelx reads
+  worksheets through a Rust extension instead of Nokogiri, building the same Roo::Excelx::Cell
+  objects. Anything the native reader does not reproduce exactly goes to roo's own
+  code. Not affiliated with roo-rb.
+executables: []
+extensions:
+- ext/roo_calamine/extconf.rb
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Cargo.lock
+- Cargo.toml
+- LICENSE
+- README.md
+- ext/roo_calamine/Cargo.toml
+- ext/roo_calamine/extconf.rb
+- ext/roo_calamine/src/convert.rs
+- ext/roo_calamine/src/lib.rs
+- ext/roo_calamine/src/reader.rs
+- lib/roo/calamine.rb
+- lib/roo/calamine/context.rb
+- lib/roo/calamine/sheet_doc.rb
+- lib/roo/calamine/version.rb
+homepage: https://github.com/salasebas/roo-calamine
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/salasebas/roo-calamine
+  source_code_uri: https://github.com/salasebas/roo-calamine/tree/v0.0.1
+  changelog_uri: https://github.com/salasebas/roo-calamine/blob/v0.0.1/CHANGELOG.md
+  bug_tracker_uri: https://github.com/salasebas/roo-calamine/issues
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.11
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A native reader that makes roo read .xlsx and .xlsm files faster, with the
+  same results.
+test_files: []