xlsxrb 0.1.14 → 0.1.16

data/lib/xlsxrb/ooxml/reader.rb

@@ -5,6 +5,7 @@
 require "zlib"
 require "rexml/parsers/sax2parser"
 require "rexml/sax2listener"
+require_relative "../number_formatter"
 
 module Xlsxrb
   module Ooxml
@@ -73,18 +74,7 @@ module Xlsxrb
 
       # Returns hyperlinks as { "A1" => "https://example.com" }.
       def hyperlinks(sheet: nil)
-        sheets = discover_sheets
-        raise ArgumentError, "workbook has no sheets" if sheets.empty?
-
-        target = resolve_sheet_target(sheets, sheet)
-        raise ArgumentError, "sheet not found: #{sheet.inspect}" if target.nil?
-
-        entry_path = if target.start_with?("/")
-                       target.delete_prefix("/")
-                     else
-                       "xl/#{target}"
-                     end
-
+        entry_path = resolve_sheet_entry_path(sheet)
         worksheet_xml = extract_zip_entry(entry_path)
         return {} if worksheet_xml.nil? || worksheet_xml.empty?
 
@@ -128,14 +118,17 @@ module Xlsxrb
         parser.parse
 
         result = {}
+        cell_xfs = styles.respond_to?(:cell_xfs) ? styles.cell_xfs : styles[:cell_xfs]
+        cell_style_xfs = styles.respond_to?(:cell_style_xfs) ? styles.cell_style_xfs : styles[:cell_style_xfs]
+        n_fmts = styles.respond_to?(:num_fmts) ? styles.num_fmts : styles[:num_fmts]
         listener.cell_style_indices.each do |cell_ref, xf_index|
-          xf = resolve_effective_xf(styles[:cell_xfs][xf_index], styles[:cell_style_xfs])
+          xf = resolve_effective_xf(cell_xfs ? cell_xfs[xf_index] : nil, cell_style_xfs)
           next unless xf
 
           fmt_id = xf[:num_fmt_id]
           next unless fmt_id && fmt_id != 0
 
-          format_code = resolve_num_fmt_code(fmt_id, styles[:num_fmts])
+          format_code = resolve_num_fmt_code(fmt_id, n_fmts)
           result[cell_ref] = format_code if format_code
         end
         result
@@ -151,16 +144,23 @@ module Xlsxrb
 
         indices = parse_cell_style_indices(worksheet_xml)
         result = {}
+        cell_xfs = styles.respond_to?(:cell_xfs) ? styles.cell_xfs : styles[:cell_xfs]
+        cell_style_xfs = styles.respond_to?(:cell_style_xfs) ? styles.cell_style_xfs : styles[:cell_style_xfs]
+        fonts_arr = styles.respond_to?(:fonts) ? styles.fonts : styles[:fonts]
+        fills_arr = styles.respond_to?(:fills) ? styles.fills : styles[:fills]
+        borders_arr = styles.respond_to?(:borders) ? styles.borders : styles[:borders]
+        n_fmts = styles.respond_to?(:num_fmts) ? styles.num_fmts : styles[:num_fmts]
+
         indices.each do |cell_ref, xf_index|
-          xf = resolve_effective_xf(styles[:cell_xfs][xf_index], styles[:cell_style_xfs])
+          xf = resolve_effective_xf(cell_xfs ? cell_xfs[xf_index] : nil, cell_style_xfs)
           next unless xf
 
           entry = {}
-          entry[:font] = styles[:fonts][xf[:font_id]] if xf[:font_id]&.positive? && styles[:fonts][xf[:font_id]]
-          entry[:fill] = styles[:fills][xf[:fill_id]] if xf[:fill_id]&.positive? && styles[:fills][xf[:fill_id]]
-          entry[:border] = styles[:borders][xf[:border_id]] if xf[:border_id]&.positive? && styles[:borders][xf[:border_id]]
+          entry[:font] = fonts_arr[xf[:font_id]] if xf[:font_id]&.positive? && fonts_arr && fonts_arr[xf[:font_id]]
+          entry[:fill] = fills_arr[xf[:fill_id]] if xf[:fill_id]&.positive? && fills_arr && fills_arr[xf[:fill_id]]
+          entry[:border] = borders_arr[xf[:border_id]] if xf[:border_id]&.positive? && borders_arr && borders_arr[xf[:border_id]]
           if xf[:num_fmt_id]&.positive?
-            code = resolve_num_fmt_code(xf[:num_fmt_id], styles[:num_fmts])
+            code = resolve_num_fmt_code(xf[:num_fmt_id], n_fmts)
             entry[:num_fmt] = code if code
           end
           entry[:alignment] = xf[:alignment] if xf[:alignment]
@@ -177,7 +177,7 @@ module Xlsxrb
         styles = load_styles
         return [] if styles.empty?
 
-        styles[:dxfs] || []
+        styles.respond_to?(:dxfs) ? styles.dxfs : (styles[:dxfs] || [])
       end
 
       # Returns array of font entries from the styles.
@@ -185,7 +185,7 @@ module Xlsxrb
         styles = load_styles
         return [] if styles.empty?
 
-        styles[:fonts] || []
+        styles.respond_to?(:fonts) ? styles.fonts : (styles[:fonts] || [])
       end
 
       # Returns array of fill entries from the styles.
@@ -193,7 +193,7 @@ module Xlsxrb
         styles = load_styles
         return [] if styles.empty?
 
-        styles[:fills] || []
+        styles.respond_to?(:fills) ? styles.fills : (styles[:fills] || [])
       end
 
       # Returns array of border entries from the styles.
@@ -201,7 +201,7 @@ module Xlsxrb
         styles = load_styles
         return [] if styles.empty?
 
-        styles[:borders] || []
+        styles.respond_to?(:borders) ? styles.borders : (styles[:borders] || [])
       end
 
       # Returns custom number formats as { numFmtId => formatCode }.
@@ -209,7 +209,7 @@ module Xlsxrb
         styles = load_styles
         return {} if styles.empty?
 
-        styles[:num_fmts] || {}
+        styles.respond_to?(:num_fmts) ? styles.num_fmts : (styles[:num_fmts] || {})
       end
 
       # Returns indexed colors palette (array of ARGB hex strings).
@@ -217,7 +217,7 @@ module Xlsxrb
         styles = load_styles
         return [] if styles.empty?
 
-        styles[:indexed_colors] || []
+        styles.respond_to?(:indexed_colors) ? styles.indexed_colors : (styles[:indexed_colors] || [])
       end
 
       # Returns MRU (most recently used) colors (array of color hashes).
@@ -225,7 +225,7 @@ module Xlsxrb
         styles = load_styles
         return [] if styles.empty?
 
-        styles[:mru_colors] || []
+        styles.respond_to?(:mru_colors) ? styles.mru_colors : (styles[:mru_colors] || [])
       end
 
       # Returns table styles configuration hash.
@@ -233,7 +233,7 @@ module Xlsxrb
         styles = load_styles
         return {} if styles.empty?
 
-        styles[:table_styles] || {}
+        styles.respond_to?(:table_styles) ? styles.table_styles : (styles[:table_styles] || {})
       end
 
       # Returns array of cellStyleXfs entries (base style format definitions).
@@ -241,7 +241,7 @@ module Xlsxrb
         styles = load_styles
         return [] if styles.empty?
 
-        styles[:cell_style_xfs] || []
+        styles.respond_to?(:cell_style_xfs) ? styles.cell_style_xfs : (styles[:cell_style_xfs] || [])
       end
 
       # Returns array of cellXfs entries (cell format definitions).
@@ -249,7 +249,7 @@ module Xlsxrb
         styles = load_styles
         return [] if styles.empty?
 
-        styles[:cell_xfs] || []
+        styles.respond_to?(:cell_xfs) ? styles.cell_xfs : (styles[:cell_xfs] || [])
       end
 
       # Returns array of named cell styles (cellStyle elements).
@@ -257,7 +257,7 @@ module Xlsxrb
         styles = load_styles
         return [] if styles.empty?
 
-        styles[:cell_styles] || []
+        styles.respond_to?(:cell_styles) ? styles.cell_styles : (styles[:cell_styles] || [])
       end
 
       # Returns the autoFilter range string (e.g. "A1:B10") or nil.
@@ -644,34 +644,15 @@ module Xlsxrb
 
       # Returns all ZIP entry paths in the file.
       def entry_names
-        names = []
-        File.open(@filepath, "rb") do |file|
-          loop do
-            sig = file.read(4)
-            break if sig.nil? || sig.bytesize < 4
-
-            sig_val = sig.unpack1("V")
-            break if [0x02014b50, 0x06054b50].include?(sig_val)
-            break unless sig_val == 0x04034b50
-
-            header = file.read(26)
-            break if header.nil? || header.bytesize < 26
-
-            _ver, flags, _cm, _mt, _md, _crc, comp_size, _unc, fname_len, extra_len = header.unpack("v v v v v V V V v v")
-            break if flags.anybits?(0x0008)
-
-            fname = file.read(fname_len)
-            file.read(extra_len)
-            file.read(comp_size)
-            names << fname
-          end
-        end
-        names
+        ZipReader.open(@filepath, &:entry_names)
       end
 
       # Returns raw bytes for a ZIP entry by path.
       def raw_entry(name)
-        extract_zip_entry(name)
+        data = extract_zip_entry(name)
+        return nil unless data
+
+        name.end_with?(".xml", ".rels", ".txt") && data.valid_encoding? ? data : data.b
       end
 
       # Returns true if the file contains VBA macros (vbaProject.bin).
@@ -971,10 +952,14 @@ module Xlsxrb
 
       STRICT_SSML_NS = "http://purl.oclc.org/ooxml/spreadsheetml/main/2006/main"
       TRANSITIONAL_SSML_NS = "http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+      OFFICE_DOC_REL_TYPES = [
+        "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument",
+        "http://purl.oclc.org/ooxml/officeDocument/relationships/officeDocument"
+      ].freeze
 
       # Returns :strict or :transitional based on the namespace of the workbook XML.
       def format_variant
-        workbook_xml = extract_zip_entry("xl/workbook.xml")
+        workbook_xml = extract_zip_entry(resolve_workbook_entry)
         return :transitional if workbook_xml.nil? || workbook_xml.empty?
 
         if workbook_xml.include?(STRICT_SSML_NS)
@@ -986,6 +971,22 @@ module Xlsxrb
 
       private
 
+      def resolve_workbook_entry
+        @resolve_workbook_entry ||= begin
+          rels_xml = extract_zip_entry("_rels/.rels")
+          target_path = nil
+          if rels_xml && !rels_xml.empty?
+            entries = parse_rels_with_types(rels_xml)
+            doc_rel = entries.find { |e| OFFICE_DOC_REL_TYPES.include?(e[:type]) }
+            if doc_rel
+              clean = doc_rel[:target].delete_prefix("/")
+              target_path = clean if extract_zip_entry(clean)
+            end
+          end
+          target_path || (extract_zip_entry("xl/workbook.xml") ? "xl/workbook.xml" : "workbook.xml")
+        end
+      end
+
       def resolve_sheet_for_defined_name(sheet)
         sheets = discover_sheets
         if sheet
@@ -1001,7 +1002,7 @@ module Xlsxrb
       end
 
       def parse_workbook_metadata
-        workbook_xml = extract_zip_entry("xl/workbook.xml")
+        workbook_xml = extract_zip_entry(resolve_workbook_entry)
         if workbook_xml.nil? || workbook_xml.empty?
           return { workbook_properties: {}, workbook_views: {}, calc_properties: {}, file_recovery_properties: {},
                    workbook_protection: nil }
@@ -1024,29 +1025,63 @@ module Xlsxrb
         }
       end
 
-      def load_worksheet_xml(sheet)
+      def resolve_sheet_entry_path(sheet)
         sheets = discover_sheets
         raise ArgumentError, "workbook has no sheets" if sheets.empty?
 
         target = resolve_sheet_target(sheets, sheet)
         raise ArgumentError, "sheet not found: #{sheet.inspect}" if target.nil?
 
-        # Target may be absolute (/xl/worksheets/sheet1.xml) or relative (worksheets/sheet1.xml).
-        entry_path = if target.start_with?("/")
-                       target.delete_prefix("/")
+        wb_dir = File.dirname(resolve_workbook_entry)
+        candidates = if target.start_with?("/")
+                       [target.delete_prefix("/")]
                      else
-                       "xl/#{target}"
+                       [
+                         wb_dir == "." ? target : "#{wb_dir}/#{target}",
+                         "xl/#{target}",
+                         target
+                       ]
                      end
+        candidates.find { |c| extract_zip_entry(c) } || candidates.first
+      end
 
+      def load_worksheet_xml(sheet)
+        entry_path = resolve_sheet_entry_path(sheet)
         extract_zip_entry(entry_path)
       end
 
+      NON_WORKSHEET_REL_SUFFIXES = %w[
+        /chartsheet
+        /dialogsheet
+        /xlMacrosheet
+        /xlIntlMacrosheet
+        /macrosheet
+      ].freeze
+      NON_WORKSHEET_TARGET_PREFIXES = %w[
+        chartsheets/
+        dialogsheets/
+        macrosheets/
+        xl/chartsheets/
+        xl/dialogsheets/
+        xl/macrosheets/
+      ].freeze
+      private_constant :NON_WORKSHEET_REL_SUFFIXES, :NON_WORKSHEET_TARGET_PREFIXES
+
       def discover_sheets
-        workbook_xml = extract_zip_entry("xl/workbook.xml")
+        wb_path = resolve_workbook_entry
+        workbook_xml = extract_zip_entry(wb_path)
         return [{ name: "Sheet1", rid: "rId1", target: "worksheets/sheet1.xml" }] if workbook_xml.nil? || workbook_xml.empty?
 
-        rels_xml = extract_zip_entry("xl/_rels/workbook.xml.rels")
-        rid_to_target = parse_rels(rels_xml)
+        wb_dir = File.dirname(wb_path)
+        rels_path = wb_dir == "." ? "_rels/#{File.basename(wb_path)}.rels" : "#{wb_dir}/_rels/#{File.basename(wb_path)}.rels"
+        rels_xml = extract_zip_entry(rels_path)
+        rel_entries = parse_rels_with_types(rels_xml)
+        rid_to_target = {}
+        rid_to_type = {}
+        rel_entries.each do |r|
+          rid_to_target[r[:id]] = r[:target]
+          rid_to_type[r[:id]] = r[:type]
+        end
 
         sheets = []
         parser = REXML::Parsers::SAX2Parser.new(workbook_xml)
@@ -1054,13 +1089,30 @@ module Xlsxrb
         parser.listen(listener)
         parser.parse
 
+        ws_idx = 0
         listener.sheets.each do |s|
-          target = rid_to_target[s[:rid]]
-          sheets << { name: s[:name], rid: s[:rid], target: target, state: s[:state] } if target
+          raw_target = rid_to_target[s[:rid]]
+          rel_type = rid_to_type[s[:rid]]
+          next if non_worksheet_relationship?(rel_type, raw_target)
+
+          target = raw_target || (wb_dir == "." ? "worksheets/sheet#{ws_idx + 1}.xml" : "#{wb_dir}/worksheets/sheet#{ws_idx + 1}.xml")
+          ws_idx += 1
+          sheets << { name: s[:name], rid: s[:rid], target: target, state: s[:state] }
         end
         sheets
       end
 
+      def non_worksheet_relationship?(rel_type, target_path)
+        return true if rel_type && NON_WORKSHEET_REL_SUFFIXES.any? { |suffix| rel_type.end_with?(suffix) }
+
+        if target_path
+          clean_target = target_path.delete_prefix("/")
+          return true if NON_WORKSHEET_TARGET_PREFIXES.any? { |prefix| clean_target.start_with?(prefix) }
+        end
+
+        false
+      end
+
       def parse_rels(rels_xml)
         return {} if rels_xml.nil? || rels_xml.empty?
 
@@ -1097,14 +1149,23 @@ module Xlsxrb
       end
 
       def load_shared_strings
-        sst_xml = extract_zip_entry("xl/sharedStrings.xml")
-        return [] if sst_xml.nil? || sst_xml.empty?
-
-        parser = REXML::Parsers::SAX2Parser.new(sst_xml)
-        listener = SharedStringsListener.new
-        parser.listen(listener)
-        parser.parse
-        listener.strings
+        wb_dir = File.dirname(resolve_workbook_entry)
+        candidates = [
+          wb_dir == "." ? "sharedStrings.xml" : "#{wb_dir}/sharedStrings.xml",
+          "xl/sharedStrings.xml",
+          "sharedStrings.xml"
+        ]
+        candidates.each do |c|
+          sst_xml = extract_zip_entry(c)
+          next if sst_xml.nil? || sst_xml.empty?
+
+          parser = REXML::Parsers::SAX2Parser.new(sst_xml)
+          listener = SharedStringsListener.new
+          parser.listen(listener)
+          parser.parse
+          return listener.strings
+        end
+        []
       end
 
       def resolve_sheet_index(sheet)
@@ -1198,21 +1259,30 @@ module Xlsxrb
       end
 
       def load_styles
-        styles_xml = extract_zip_entry("xl/styles.xml")
-        return {} if styles_xml.nil? || styles_xml.empty?
-
-        parser = REXML::Parsers::SAX2Parser.new(styles_xml)
-        listener = StylesListener.new
-        parser.listen(listener)
-        parser.parse
-        {
-          num_fmts: listener.num_fmts, cell_xfs: listener.cell_xfs,
-          cell_style_xfs: listener.cell_style_xfs, cell_styles: listener.cell_styles,
-          fonts: listener.fonts, fills: listener.fills,
-          borders: listener.borders, dxfs: listener.dxfs,
-          indexed_colors: listener.indexed_colors, mru_colors: listener.mru_colors,
-          table_styles: listener.table_styles
-        }
+        wb_dir = File.dirname(resolve_workbook_entry)
+        candidates = [
+          wb_dir == "." ? "styles.xml" : "#{wb_dir}/styles.xml",
+          "xl/styles.xml",
+          "styles.xml"
+        ]
+        candidates.each do |c|
+          styles_xml = extract_zip_entry(c)
+          next if styles_xml.nil? || styles_xml.empty?
+
+          parser = REXML::Parsers::SAX2Parser.new(styles_xml)
+          listener = StylesListener.new
+          parser.listen(listener)
+          parser.parse
+          return {
+            num_fmts: listener.num_fmts, cell_xfs: listener.cell_xfs,
+            cell_style_xfs: listener.cell_style_xfs, cell_styles: listener.cell_styles,
+            fonts: listener.fonts, fills: listener.fills,
+            borders: listener.borders, dxfs: listener.dxfs,
+            indexed_colors: listener.indexed_colors, mru_colors: listener.mru_colors,
+            table_styles: listener.table_styles
+          }
+        end
+        {}
       end
 
       def parse_cell_style_indices(xml)
@@ -1225,17 +1295,21 @@ module Xlsxrb
 
       def resolve_date_cells(raw_cells, cell_style_map, styles)
         is_date1904 = workbook_properties&.[](:date1904) || false
+        cell_xfs = styles.respond_to?(:cell_xfs) ? styles.cell_xfs : styles[:cell_xfs]
+        cell_style_xfs = styles.respond_to?(:cell_style_xfs) ? styles.cell_style_xfs : styles[:cell_style_xfs]
+        n_fmts = styles.respond_to?(:num_fmts) ? styles.num_fmts : styles[:num_fmts]
+
         raw_cells.each do |cell_ref, value|
           next unless value.is_a?(Numeric)
 
           xf_index = cell_style_map[cell_ref]
           next unless xf_index
 
-          xf = resolve_effective_xf(styles[:cell_xfs][xf_index], styles[:cell_style_xfs])
+          xf = resolve_effective_xf(cell_xfs ? cell_xfs[xf_index] : nil, cell_style_xfs)
           next unless xf
 
           fmt_id = xf[:num_fmt_id]
-          next unless date_format?(fmt_id, styles[:num_fmts])
+          next unless date_format?(fmt_id, n_fmts)
 
           raw_cells[cell_ref] = if value.is_a?(Float) && (value % 1).positive?
                                   Xlsxrb::Ooxml::Utils.serial_to_datetime(value, date1904: is_date1904)
@@ -1280,57 +1354,11 @@ module Xlsxrb
       end
 
       def date_pattern?(code)
-        # Strip quoted strings to avoid false matches.
-        stripped = code.gsub(/"[^"]*"/, "").gsub(/\\[.]/, "")
-        stripped.match?(/[ymdhsYMDHS]/)
+        NumberFormatter.date_format?(code)
       end
 
       def extract_zip_entry(entry_name)
-        File.open(@filepath, "rb") do |file|
-          loop do
-            signature = file.read(4)
-            break if signature.nil? || signature.bytesize < 4
-
-            signature_value = signature.unpack1("V")
-            break if [0x02014b50, 0x06054b50].include?(signature_value)
-
-            raise ZipError, "invalid ZIP local header signature" unless signature_value == 0x04034b50
-
-            header = file.read(26)
-            raise ZipError, "truncated ZIP local header" if header.nil? || header.bytesize < 26
-
-            _version, flags, compression_method, _mtime, _mdate, _crc32, compressed_size,
-              _uncompressed_size, file_name_length, extra_field_length = header.unpack("v v v v v V V V v v")
-
-            raise ZipError, "ZIP data descriptor is not supported" if flags.anybits?(0x0008)
-
-            file_name = file.read(file_name_length)
-            raise ZipError, "truncated ZIP file name" if file_name.nil? || file_name.bytesize < file_name_length
-
-            file.read(extra_field_length)
-
-            compressed_data = file.read(compressed_size)
-            raise ZipError, "truncated ZIP entry data" if compressed_data.nil? || compressed_data.bytesize < compressed_size
-
-            next unless file_name == entry_name
-
-            case compression_method
-            when 0
-              return compressed_data
-            when 8
-              inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
-              begin
-                return inflater.inflate(compressed_data)
-              ensure
-                inflater.close
-              end
-            else
-              raise ZipError, "unsupported ZIP compression method: #{compression_method}"
-            end
-          end
-        end
-
-        nil
+        ZipReader.open(@filepath) { |zr| zr.read_entry(entry_name) }
       end
 
       def parse_worksheet_cells(xml, shared_strings)