rbxl 1.0.0

data/lib/rbxl/native.rb

@@ -0,0 +1,15 @@
+begin
+  require "rbxl_native/rbxl_native"
+rescue LoadError
+  # Try loading from ext/ build directory (development)
+  ext_path = File.expand_path("../../ext/rbxl_native", __dir__)
+  so = Dir.glob(File.join(ext_path, "**", "rbxl_native.{so,bundle,dll}")).first
+  if so
+    require so
+  else
+    raise LoadError,
+      "rbxl_native C extension not found. " \
+      "Ensure libxml2 development headers are installed and run: " \
+      "cd ext/rbxl_native && ruby extconf.rb && make"
+  end
+end

data/lib/rbxl/read_only_cell.rb

@@ -0,0 +1,3 @@
+module Rbxl
+  ReadOnlyCell = Data.define(:coordinate, :value)
+end

data/lib/rbxl/read_only_workbook.rb

@@ -0,0 +1,153 @@
+module Rbxl
+  class ReadOnlyWorkbook
+    MAIN_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+    REL_NS = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+    PACKAGE_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships"
+
+    attr_reader :path, :sheet_names
+
+    def self.open(path)
+      new(path)
+    end
+
+    def initialize(path)
+      @path = path
+      @zip = Zip::File.open(path)
+      @shared_strings = load_shared_strings
+      @sheet_entries = load_sheet_entries
+      @sheet_names = @sheet_entries.keys.freeze
+      @closed = false
+    end
+
+    def sheet(name)
+      ensure_open!
+
+      entry_path = @sheet_entries.fetch(name) do
+        raise SheetNotFoundError, "sheet not found: #{name}"
+      end
+
+      ReadOnlyWorksheet.new(zip: @zip, entry_path: entry_path, shared_strings: @shared_strings, name: name)
+    end
+
+    def close
+      return if closed?
+
+      @zip.close
+      @closed = true
+    end
+
+    def closed?
+      @closed
+    end
+
+    private
+
+    def ensure_open!
+      raise ClosedWorkbookError, "workbook has been closed" if closed?
+    end
+
+    def load_shared_strings
+      entry = @zip.find_entry("xl/sharedStrings.xml")
+      return [] unless entry
+
+      strings = []
+      io = entry.get_input_stream
+      reader = Nokogiri::XML::Reader(io)
+
+      in_si = false
+      in_run = false
+      in_phonetic = false
+      collecting_text = false
+      buffer = +""
+      current_fragments = []
+
+      reader.each do |node|
+        case node.node_type
+        when Nokogiri::XML::Reader::TYPE_ELEMENT
+          case node.local_name
+          when "si"
+            in_si = true
+            current_fragments = []
+          when "r"
+            in_run = true if in_si
+          when "rPh"
+            in_phonetic = true if in_si
+          when "t"
+            next unless in_si && !in_phonetic
+
+            collecting_text = !in_run || node.depth.positive?
+            buffer.clear if collecting_text
+          end
+        when Nokogiri::XML::Reader::TYPE_TEXT, Nokogiri::XML::Reader::TYPE_CDATA
+          buffer << node.value if collecting_text
+        when Nokogiri::XML::Reader::TYPE_END_ELEMENT
+          case node.local_name
+          when "t"
+            if collecting_text
+              current_fragments << buffer.dup
+              collecting_text = false
+            end
+          when "r"
+            in_run = false
+          when "rPh"
+            in_phonetic = false
+          when "si"
+            strings << current_fragments.join.freeze
+            in_si = false
+            in_run = false
+            in_phonetic = false
+            collecting_text = false
+          end
+        end
+      end
+
+      strings
+    ensure
+      io&.close
+    end
+
+    def load_sheet_entries
+      relationships = load_relationship_targets("xl/_rels/workbook.xml.rels")
+      sheets = {}
+
+      each_xml_node("xl/workbook.xml") do |node|
+        next unless node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
+        next unless node.local_name == "sheet"
+
+        name = node.attribute("name")
+        rid = node.attribute("r:id")
+        next unless name && rid
+
+        target = relationships.fetch(rid)
+        sheets[name] = "xl/#{target}".gsub(%r{/+}, "/")
+      end
+
+      sheets
+    end
+
+    def load_relationship_targets(entry_path)
+      relationships = {}
+
+      each_xml_node(entry_path) do |node|
+        next unless node.node_type == Nokogiri::XML::Reader::TYPE_ELEMENT
+        next unless node.local_name == "Relationship"
+
+        id = node.attribute("Id")
+        target = node.attribute("Target")
+        next unless id && target
+
+        relationships[id] = target
+      end
+
+      relationships
+    end
+
+    def each_xml_node(entry_path)
+      io = @zip.get_entry(entry_path).get_input_stream
+      reader = Nokogiri::XML::Reader(io)
+      reader.each { |node| yield node }
+    ensure
+      io&.close
+    end
+  end
+end

data/lib/rbxl/read_only_worksheet.rb

@@ -0,0 +1,501 @@
+module Rbxl
+  class ReadOnlyWorksheet
+    ELEMENT_NODE = Nokogiri::XML::Reader::TYPE_ELEMENT
+    TEXT_NODE = Nokogiri::XML::Reader::TYPE_TEXT
+    CDATA_NODE = Nokogiri::XML::Reader::TYPE_CDATA
+    END_ELEMENT_NODE = Nokogiri::XML::Reader::TYPE_END_ELEMENT
+
+    attr_reader :name, :dimensions
+
+    def initialize(zip:, entry_path:, shared_strings:, name:)
+      @zip = zip
+      @entry_path = entry_path
+      @shared_strings = shared_strings
+      @name = name
+      @dimensions = extract_dimensions
+      @merge_ranges_by_row = nil
+      @merge_anchor_values = {}
+    end
+
+    def each_row(pad_cells: false, values_only: false, expand_merged: false, &block)
+      return enum_for(:each_row, pad_cells: pad_cells, values_only: values_only, expand_merged: expand_merged) unless block
+
+      if values_only && !pad_cells && !expand_merged
+        each_row_values_only(&block)
+      else
+        each_row_full(pad_cells: pad_cells, values_only: values_only, expand_merged: expand_merged, &block)
+      end
+    end
+
+    def rows(values_only: false, pad_cells: false, expand_merged: false)
+      each_row(values_only: values_only, pad_cells: pad_cells, expand_merged: expand_merged)
+    end
+
+    def max_column
+      return nil unless dimensions
+
+      dimensions[:max_col]
+    end
+
+    def max_row
+      return nil unless dimensions
+
+      dimensions[:max_row]
+    end
+
+    def reset_dimensions
+      @dimensions = nil
+    end
+
+    def calculate_dimension(force: false)
+      if dimensions
+        return dimensions[:ref]
+      end
+
+      raise UnsizedWorksheetError, "worksheet is unsized, use force: true" unless force
+
+      @dimensions = scan_dimensions
+      dimensions ? dimensions[:ref] : "A1:A1"
+    end
+
+    private
+
+    def each_row_values_only(&block)
+      if defined?(Rbxl::Native) && !@disable_native
+        xml = @zip.get_entry(@entry_path).get_input_stream.read
+        Rbxl::Native.parse_sheet(xml, @shared_strings, &block)
+        return
+      end
+
+      cell_type = nil
+      collecting_value = false
+      in_v = false
+      raw_value = nil
+      value_buffer = +""
+      current_values = nil
+      row_depth = nil
+
+      with_sheet_reader do |reader|
+        reader.each do |node|
+          case node.node_type
+          when ELEMENT_NODE
+            case node.local_name
+            when "row"
+              current_values = []
+              row_depth = node.depth
+            when "c"
+              cell_type = node.attribute("t")
+              raw_value = nil
+            when "v"
+              collecting_value = true
+              in_v = true
+              value_buffer.clear
+            when "t"
+              collecting_value = true
+              value_buffer.clear
+            end
+          when TEXT_NODE, CDATA_NODE
+            value_buffer << node.value if collecting_value
+          when END_ELEMENT_NODE
+            if collecting_value
+              if in_v
+                raw_value = value_buffer.dup
+                collecting_value = false
+                in_v = false
+              else
+                raw_value = raw_value ? raw_value << value_buffer : value_buffer.dup
+                collecting_value = false
+              end
+            elsif node.depth == row_depth
+              yield current_values.freeze
+              current_values = nil
+            elsif current_values && node.depth == row_depth + 1
+              current_values << coerce_value(raw_value, cell_type)
+              cell_type = nil
+              raw_value = nil
+            end
+          end
+        end
+      end
+    end
+
+    def each_row_full(pad_cells:, values_only:, expand_merged:, &block)
+      if defined?(Rbxl::Native) && !@disable_native && !pad_cells && !expand_merged && !values_only
+        xml = @zip.get_entry(@entry_path).get_input_stream.read
+        Rbxl::Native.parse_sheet_full(xml, @shared_strings, &block)
+        return
+      end
+
+      current_row_index = nil
+      last_row_index = 0
+      current_cells = nil
+      cell_ref = nil
+      cell_type = nil
+      current_col_index = 0
+      collecting_value = false
+      in_v = false
+      raw_value = nil
+      value_buffer = +""
+      row_depth = nil
+
+      with_sheet_reader do |reader|
+        reader.each do |node|
+          case node.node_type
+          when ELEMENT_NODE
+            case node.local_name
+            when "row"
+              current_row_index = attribute_int(node, "r") || (last_row_index + 1)
+              current_col_index = 0
+              current_cells = []
+              row_depth = node.depth
+            when "c"
+              cell_ref = node.attribute("r")
+              if cell_ref
+                current_col_index = split_col_index(cell_ref)
+              else
+                current_col_index += 1
+                cell_ref = "#{column_name(current_col_index)}#{current_row_index}"
+              end
+              cell_type = node.attribute("t")
+              raw_value = nil
+            when "v"
+              collecting_value = true
+              in_v = true
+              value_buffer.clear
+            when "t"
+              collecting_value = true
+              value_buffer.clear
+            end
+          when TEXT_NODE, CDATA_NODE
+            value_buffer << node.value if collecting_value
+          when END_ELEMENT_NODE
+            if collecting_value
+              if in_v
+                raw_value = value_buffer.dup
+                collecting_value = false
+                in_v = false
+              else
+                raw_value = raw_value ? raw_value << value_buffer : value_buffer.dup
+                collecting_value = false
+              end
+            elsif node.depth == row_depth
+              current_cells = pad_row(current_cells, current_row_index, values_only: values_only) if pad_cells
+              current_cells = expand_merged_cells(current_cells, current_row_index, values_only: values_only) if expand_merged
+              yield values_only ? extract_values(current_cells).freeze : Row.new(index: current_row_index, cells: current_cells)
+              last_row_index = current_row_index
+              current_row_index = nil
+              current_cells = nil
+            elsif current_cells && node.depth == row_depth + 1
+              current_cells << build_row_entry(cell_ref, coerce_value(raw_value, cell_type), values_only)
+              cell_ref = nil
+              cell_type = nil
+              raw_value = nil
+            end
+          end
+        end
+      end
+    end
+
+    def with_sheet_reader
+      io = @zip.get_entry(@entry_path).get_input_stream
+      reader = Nokogiri::XML::Reader(io)
+      yield reader
+    ensure
+      io&.close
+    end
+
+    def extract_dimensions
+      with_sheet_reader do |reader|
+        reader.each do |node|
+          next unless node.node_type == ELEMENT_NODE && node.local_name == "dimension"
+
+          return parse_range(node.attribute("ref"))
+        end
+      end
+
+      nil
+    end
+
+    def extract_merge_ranges_by_row
+      ranges_by_row = Hash.new { |hash, key| hash[key] = [] }
+
+      with_sheet_reader do |reader|
+        reader.each do |node|
+          next unless node.node_type == ELEMENT_NODE && node.local_name == "mergeCell"
+
+          range = parse_merge_range(node.attribute("ref"))
+          next unless range
+
+          (range[:start_row]..range[:end_row]).each do |row|
+            ranges_by_row[row] << range
+          end
+        end
+      end
+
+      ranges_by_row
+    end
+
+    def scan_dimensions
+      max_col = nil
+      max_row = nil
+
+      with_sheet_reader do |reader|
+        reader.each do |node|
+          next unless node.node_type == ELEMENT_NODE && node.local_name == "c"
+
+          coordinate = node.attribute("r")
+          col, row = split_coordinate(coordinate)
+          next unless col && row
+
+          max_col = col if max_col.nil? || col > max_col
+          max_row = row if max_row.nil? || row > max_row
+        end
+      end
+
+      return nil unless max_col && max_row
+
+      { ref: "A1:#{column_name(max_col)}#{max_row}", max_col: max_col, max_row: max_row }
+    end
+
+    def parse_range(reference)
+      return nil if reference.nil? || reference.empty?
+
+      start_ref, finish_ref = reference.split(":", 2)
+      finish_ref ||= start_ref
+      _, _, max_col, max_row = *range_bounds(start_ref, finish_ref)
+      { ref: reference, max_col: max_col, max_row: max_row }
+    end
+
+    def parse_merge_range(reference)
+      return nil if reference.nil? || reference.empty?
+
+      start_ref, finish_ref = reference.split(":", 2)
+      finish_ref ||= start_ref
+      start_col, start_row, end_col, end_row = *range_bounds(start_ref, finish_ref)
+      return nil unless start_col && start_row && end_col && end_row
+
+      {
+        start_col: start_col,
+        start_row: start_row,
+        end_col: end_col,
+        end_row: end_row
+      }
+    end
+
+    def range_bounds(start_ref, finish_ref)
+      start_col, start_row = split_coordinate(start_ref)
+      finish_col, finish_row = split_coordinate(finish_ref)
+      [start_col, start_row, finish_col, finish_row]
+    end
+
+    def split_coordinate(reference)
+      col = 0
+      i = 0
+      len = reference.length
+
+      while i < len
+        byte = reference.getbyte(i)
+        break unless byte >= 65 && byte <= 90 # A-Z
+
+        col = (col * 26) + (byte - 64)
+        i += 1
+      end
+
+      return [nil, nil] if i == 0 || i == len
+
+      row = 0
+      while i < len
+        byte = reference.getbyte(i)
+        return [nil, nil] unless byte >= 48 && byte <= 57 # 0-9
+
+        row = (row * 10) + (byte - 48)
+        i += 1
+      end
+
+      [col, row]
+    end
+
+    def column_index(label)
+      col = 0
+      i = 0
+      len = label.length
+      while i < len
+        col = (col * 26) + (label.getbyte(i) - 64)
+        i += 1
+      end
+      col
+    end
+
+    def split_col_index(reference)
+      col = 0
+      i = 0
+      len = reference.length
+
+      while i < len
+        byte = reference.getbyte(i)
+        break unless byte >= 65 && byte <= 90
+
+        col = (col * 26) + (byte - 64)
+        i += 1
+      end
+
+      col
+    end
+
+    def pad_row(cells, row_index, values_only:)
+      return cells unless dimensions && dimensions[:max_col]
+
+      by_column = cells.each_with_object({}) do |cell, acc|
+        coordinate =
+          if cell.respond_to?(:coordinate)
+            cell.coordinate
+          elsif values_only
+            cell[0]
+          end
+        next unless coordinate
+
+        acc[column_index(coordinate[/\A[A-Z]+/])] = cell
+      end
+
+      (1..dimensions[:max_col]).map do |col|
+        by_column[col] || (values_only ? [nil, nil] : EmptyCell.new(coordinate: "#{column_name(col)}#{row_index}"))
+      end
+    end
+
+    def expand_merged_cells(cells, row_index, values_only:)
+      merge_ranges = merge_ranges_by_row[row_index]
+      return cells if merge_ranges.empty?
+
+      expanded_cells = cells.dup
+
+      merge_ranges.each do |range|
+        if row_index == range[:start_row]
+          @merge_anchor_values[range] = value_at(expanded_cells, range[:start_col], values_only: values_only)
+        end
+
+        anchor_value = @merge_anchor_values[range]
+        next if anchor_value.nil?
+
+        (range[:start_col]..range[:end_col]).each do |col|
+          next if row_index == range[:start_row] && col == range[:start_col]
+
+          expanded_cells = set_value_at(expanded_cells, row_index, col, anchor_value, values_only: values_only)
+        end
+      end
+
+      expanded_cells
+    end
+
+    def value_at(cells, col_index, values_only:)
+      cell = cells[col_index - 1]
+      return nil unless cell
+
+      if values_only
+        cell[1]
+      elsif cell.is_a?(EmptyCell)
+        nil
+      else
+        cell.value
+      end
+    end
+
+    def set_value_at(cells, row_index, col_index, value, values_only:)
+      if values_only
+        coordinate = "#{column_name(col_index)}#{row_index}"
+        cells[col_index - 1] = [coordinate, value]
+      else
+        coordinate = "#{column_name(col_index)}#{row_index}"
+        cells[col_index - 1] = ReadOnlyCell.new(coordinate, value)
+      end
+
+      cells
+    end
+
+    def merge_ranges_by_row
+      @merge_ranges_by_row ||= extract_merge_ranges_by_row
+    end
+
+    def coerce_value(raw_value, type)
+      case type
+      when "s"
+        @shared_strings[raw_value.to_i]
+      when "inlineStr", "str"
+        raw_value
+      when "b"
+        raw_value == "1"
+      else
+        infer_scalar(raw_value)
+      end
+    end
+
+    def infer_scalar(raw_value)
+      return nil if raw_value.nil? || raw_value.empty?
+
+      numeric_kind = detect_numeric_kind(raw_value)
+      return raw_value.to_i if numeric_kind == :integer
+      return raw_value.to_f if numeric_kind == :float
+
+      raw_value
+    end
+
+    def detect_numeric_kind(value)
+      index = 0
+      length = value.length
+      saw_digit = false
+      saw_dot = false
+
+      if value.getbyte(0) == 45
+        index = 1
+        return nil if length == 1
+      end
+
+      while index < length
+        byte = value.getbyte(index)
+
+        if byte >= 48 && byte <= 57
+          saw_digit = true
+        elsif byte == 46
+          return nil if saw_dot
+
+          saw_dot = true
+        else
+          return nil
+        end
+
+        index += 1
+      end
+
+      return nil unless saw_digit
+
+      saw_dot ? :float : :integer
+    end
+
+    def column_name(index)
+      name = +""
+      current = index
+
+      while current.positive?
+        current -= 1
+        name.prepend((65 + (current % 26)).chr)
+        current /= 26
+      end
+
+      name
+    end
+
+    def attribute_int(node, key)
+      value = node.attribute(key)
+      value&.to_i
+    end
+
+    def build_row_entry(coordinate, value, values_only)
+      return [coordinate, value] if values_only
+
+      ReadOnlyCell.new(coordinate, value)
+    end
+
+    def extract_values(cells)
+      cells.map { |cell| cell.is_a?(Array) ? cell[1] : cell }
+    end
+  end
+end

data/lib/rbxl/row.rb

@@ -0,0 +1,23 @@
+module Rbxl
+  class Row
+    attr_reader :index, :cells
+
+    def initialize(index:, cells:)
+      @index = index
+      @cells = cells.freeze
+      @values = nil
+    end
+
+    def [](offset)
+      cells[offset]
+    end
+
+    def values
+      @values ||= cells.map(&:value).freeze
+    end
+
+    def size
+      cells.size
+    end
+  end
+end

data/lib/rbxl/version.rb

@@ -0,0 +1,3 @@
+module Rbxl
+  VERSION = "1.0.0"
+end

data/lib/rbxl/write_only_cell.rb

@@ -0,0 +1,10 @@
+module Rbxl
+  class WriteOnlyCell
+    attr_reader :value, :style_id
+
+    def initialize(value, style_id: nil)
+      @value = value
+      @style_id = style_id
+    end
+  end
+end