xlsxrb 0.1.13 → 0.1.15

data/lib/xlsxrb/ooxml/writer.rb

@@ -330,6 +330,19 @@ module Xlsxrb
         validate_cell_address!(cell_address)
         sheet_name = sheet || @sheet_order.first
         raise ArgumentError, "unknown sheet: #{sheet_name}" unless @hyperlinks.key?(sheet_name)
+
+        if url.is_a?(Elements::Hyperlink)
+          link = {}
+          link[:url] = url.url if url.url
+          link[:display] = url.display || display if url.display || display
+          link[:tooltip] = url.tooltip || tooltip if url.tooltip || tooltip
+          link[:location] = url.location || location if url.location || location
+          raise ArgumentError, "url or location required" if link[:url].nil? && link[:location].nil?
+
+          @hyperlinks[sheet_name][cell_address] = link
+          return
+        end
+
         raise ArgumentError, "url or location required" if url.nil? && location.nil?
 
         link = {}
@@ -997,6 +1010,7 @@ module Xlsxrb
       def set_workbook_property(name, value)
         @workbook_properties[name] = value
       end
+      alias workbook_property set_workbook_property
 
       # Returns workbook properties hash.
       # : () -> untyped

data/lib/xlsxrb/ooxml/xml_builder.rb

@@ -118,14 +118,26 @@ module Xlsxrb
         str.match?(ESCAPE_RE) ? str.gsub(ESCAPE_RE, ESCAPE_MAP) : str
       end
 
-      # Unescapes predefined XML entities in a string in a single pass.
+      NUM_ENTITY_RE = /&#(?:(\d+)|x([0-9a-fA-F]+));/
+      private_constant :NUM_ENTITY_RE
+
+      # Unescapes predefined and numeric/hex XML entities in a string.
       #
       # @param value [Object]
       # @return [String]
       #: (untyped value) -> String
       def self.unescape(value)
         str = value.to_s
-        str.include?("&") ? str.gsub(UNESCAPE_RE, UNESCAPE_MAP) : str
+        return str unless str.include?("&")
+
+        res = str.gsub(UNESCAPE_RE, UNESCAPE_MAP)
+        res.gsub(NUM_ENTITY_RE) do |match|
+          dec = Regexp.last_match(1)
+          codepoint = dec ? Integer(dec) : Integer(Regexp.last_match(2), 16)
+          codepoint.chr(Encoding::UTF_8)
+        rescue RangeError
+          match
+        end
       end
 
       private

data/lib/xlsxrb/ooxml/zip_reader.rb

@@ -49,6 +49,7 @@ module Xlsxrb
           @total_uncompressed = 0
           @eof = false
           @closed = false
+          @bom_checked = false
           @inflater = @compression_method == 8 ? Zlib::Inflate.new(-Zlib::MAX_WBITS) : nil
         end
 
@@ -56,6 +57,8 @@ module Xlsxrb
         def read(length = nil)
           raise IOError, "closed stream" if @closed
 
+          check_bom_encoding!
+
           if length.nil?
             result = @buffer.dup
             @buffer.clear
@@ -96,6 +99,11 @@ module Xlsxrb
           return if @closed
 
           @closed = true
+          begin
+            @inflater&.reset
+          rescue StandardError
+            nil
+          end
           @inflater&.close
           @inflater = nil
           @buffer.clear
@@ -176,18 +184,48 @@ module Xlsxrb
             nil
           end
         end
+
+        def check_bom_encoding!
+          return if @bom_checked
+
+          @bom_checked = true
+          peek = fetch_chunk(DEFAULT_CHUNK_SIZE)
+          return unless peek
+
+          raw_b = peek.b
+          if raw_b.start_with?("\xFF\xFE".b)
+            rest = +""
+            while (chunk = fetch_chunk(DEFAULT_CHUNK_SIZE))
+              rest << chunk
+            end
+            full = (peek + rest).force_encoding(Encoding::UTF_16LE).encode(Encoding::UTF_8).delete_prefix("\uFEFF")
+            @buffer = full
+            @eof = true
+          elsif raw_b.start_with?("\xFE\xFF".b)
+            rest = +""
+            while (chunk = fetch_chunk(DEFAULT_CHUNK_SIZE))
+              rest << chunk
+            end
+            full = (peek + rest).force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8).delete_prefix("\uFEFF")
+            @buffer = full
+            @eof = true
+          elsif raw_b.start_with?("\xEF\xBB\xBF".b)
+            @buffer << peek.b.delete_prefix("\xEF\xBB\xBF".b).force_encoding(Encoding::UTF_8)
+          else
+            @buffer << peek
+          end
+        end
       end
 
       # Opens a ZIP from a file path or IO and yields the reader.
       #: (untyped source, ?max_uncompressed_size: Integer) ?{ (ZipReader) -> untyped } -> (ZipReader | untyped)
       def self.open(source, max_uncompressed_size: MAX_UNCOMPRESSED_SIZE)
-        should_close = source.is_a?(String) && File.file?(source)
-        io = if source.is_a?(String)
-               if source.start_with?(LOCAL_HEADER_SIG) || source.include?("\x00")
-                 StringIO.new(source.b)
-               else
-                 File.open(source, "rb")
-               end
+        is_binary = source.is_a?(String) && (source.start_with?(LOCAL_HEADER_SIG) || source.include?("\x00"))
+        should_close = source.is_a?(String) && !is_binary && File.file?(source)
+        io = if should_close
+               File.open(source, "rb")
+             elsif source.is_a?(String)
+               StringIO.new(source.b)
              else
                source
              end
@@ -211,6 +249,7 @@ module Xlsxrb
         @tempfile = nil
         @io = nil
         @catalog = nil
+        @ci_catalog = nil
         @cached_entries = nil
       end
 
@@ -227,11 +266,15 @@ module Xlsxrb
       # Returns raw bytes for a single entry, or nil if not found.
       #: (String name) -> String?
       def read_entry(name)
-        return @cached_entries[name] if @cached_entries&.key?(name)
+        norm_name = normalize_entry_name(name)
+        cached = @cached_entries[norm_name] if @cached_entries&.key?(norm_name)
 
-        entry = catalog[name]
+        entry = lookup_entry(norm_name)
         return nil unless entry
 
+        cached ||= @cached_entries[entry.name] if @cached_entries&.key?(entry.name)
+        return normalize_text_encoding(cached) if cached
+
         io.seek(entry.data_offset, IO::SEEK_SET)
         raw = io.read(entry.compressed_size)
         decompress(raw, entry.method)
@@ -250,7 +293,7 @@ module Xlsxrb
       # Opens an EntryStreamIO for an entry by name.
       #: (String entry_name) -> EntryStreamIO
       def open_entry_io(entry_name)
-        entry = catalog[entry_name]
+        entry = lookup_entry(entry_name)
         raise ArgumentError, "Entry not found in archive: #{entry_name}" unless entry
 
         EntryStreamIO.new(io, entry.data_offset, entry.compressed_size, entry.method, max_uncompressed_size: @max_uncompressed_size)
@@ -272,7 +315,7 @@ module Xlsxrb
       # Returns true if the archive contains the specified entry.
       #: (String name) -> bool
       def entry?(name)
-        catalog.key?(name)
+        !lookup_entry(name).nil?
       end
 
       # Returns entry metadata catalog.
@@ -290,7 +333,7 @@ module Xlsxrb
       # Copies the specified entry to a ZipWriter directly without decompression.
       #: (String entry_name, ZipWriter writer, ?target_path: String?) -> void
       def copy_to_writer(entry_name, writer, target_path: nil)
-        entry = catalog[entry_name]
+        entry = lookup_entry(entry_name)
         raise ArgumentError, "Entry not found in archive: #{entry_name}" unless entry
 
         if entry.compressed_size.zero? && entry.uncompressed_size.positive?
@@ -354,7 +397,7 @@ module Xlsxrb
         cd_catalog = parse_catalog_from_central_directory(io)
         return cd_catalog if cd_catalog && !cd_catalog.empty?
 
-        io.seek(-4, IO::SEEK_CUR) if io.respond_to?(:seek)
+        io.seek(0, IO::SEEK_SET) if io.respond_to?(:seek)
         parse_catalog_from_local_headers(io)
       end
 
@@ -394,9 +437,13 @@ module Xlsxrb
 
           _v_made, _v_need, _gp, method, _time, _date, crc, csize, usize, nlen, elen, clen, _dnum, _iattr, _eattr, offset = cd_header.unpack("vvvvvvVVVvvvvvVV")
           entry_name = io.read(nlen).force_encoding("UTF-8")
-          io.read(elen + clen)
+          extra_data = elen.positive? ? io.read(elen) : nil
+          io.read(clen) if clen.positive?
 
-          next if entry_name.end_with?("/")
+          usize, csize, offset = parse_zip64_extra(extra_data, usize, csize, offset) if extra_data && (usize == 0xFFFF_FFFF || csize == 0xFFFF_FFFF || offset == 0xFFFF_FFFF)
+
+          norm_name = normalize_entry_name(entry_name)
+          next if norm_name.end_with?("/")
 
           current_cd_pos = io.pos
 
@@ -411,8 +458,8 @@ module Xlsxrb
           local_elen = local_header[24, 2].unpack1("v")
           data_offset = offset + 30 + local_nlen + local_elen
 
-          result[entry_name] = Entry.new(
-            name: entry_name,
+          entry = Entry.new(
+            name: norm_name,
             method: method,
             compressed_size: csize,
             uncompressed_size: usize,
@@ -420,6 +467,8 @@ module Xlsxrb
             local_header_offset: offset,
             data_offset: data_offset
           )
+          result[norm_name] = entry
+          result[entry_name] = entry if entry_name != norm_name
 
           io.seek(current_cd_pos, IO::SEEK_SET)
         end
@@ -450,19 +499,22 @@ module Xlsxrb
           extra_len       = header[24, 2].unpack1("v")
 
           entry_name = io.read(name_len).force_encoding("UTF-8")
-          io.read(extra_len)
+          extra_data = extra_len.positive? ? io.read(extra_len) : nil
+          uncompressed_size, compressed_size, = parse_zip64_extra(extra_data, uncompressed_size, compressed_size, 0) if extra_data && (uncompressed_size == 0xFFFF_FFFF || compressed_size == 0xFFFF_FFFF)
           data_offset = io.pos
 
-          next if entry_name.end_with?("/")
+          norm_name = normalize_entry_name(entry_name)
+          next if norm_name.end_with?("/")
 
           has_data_descriptor = gp_flag.anybits?(0x08)
 
           if has_data_descriptor && compressed_size.zero?
             entry_data, = find_data_descriptor_stream(io, method)
             @cached_entries ||= {}
-            @cached_entries[entry_name] = entry_data
-            result[entry_name] = Entry.new(
-              name: entry_name,
+            @cached_entries[norm_name] = entry_data
+            @cached_entries[entry_name] = entry_data if entry_name != norm_name
+            entry = Entry.new(
+              name: norm_name,
               method: method,
               compressed_size: entry_data.bytesize,
               uncompressed_size: entry_data.bytesize,
@@ -470,9 +522,11 @@ module Xlsxrb
               local_header_offset: header_pos,
               data_offset: data_offset
             )
+            result[norm_name] = entry
+            result[entry_name] = entry if entry_name != norm_name
           else
-            result[entry_name] = Entry.new(
-              name: entry_name,
+            entry = Entry.new(
+              name: norm_name,
               method: method,
               compressed_size: compressed_size,
               uncompressed_size: uncompressed_size,
@@ -480,6 +534,8 @@ module Xlsxrb
               local_header_offset: header_pos,
               data_offset: data_offset
             )
+            result[norm_name] = entry
+            result[entry_name] = entry if entry_name != norm_name
 
             io.seek(compressed_size, IO::SEEK_CUR) if io.respond_to?(:seek)
           end
@@ -527,11 +583,15 @@ module Xlsxrb
       end
 
       def decompress(raw, method)
-        return raw&.dup&.force_encoding("UTF-8") || "" if method.zero?
-
-        safe_inflate(raw || "", -Zlib::MAX_WBITS)
+        data = if method.zero?
+                 raw&.dup || ""
+               else
+                 safe_inflate(raw || "", -Zlib::MAX_WBITS)
+               end
+        normalize_text_encoding(data)
       rescue Zlib::DataError
-        safe_inflate(raw || "", -Zlib::MAX_WBITS)
+        data = safe_inflate(raw || "", -Zlib::MAX_WBITS)
+        normalize_text_encoding(data)
       end
 
       def safe_inflate(raw, wbits)
@@ -561,6 +621,62 @@ module Xlsxrb
 
         result.force_encoding("UTF-8")
       end
+
+      def normalize_entry_name(name)
+        name.include?("\\") ? name.tr("\\", "/") : name
+      end
+
+      def lookup_entry(name)
+        norm_name = normalize_entry_name(name)
+        catalog[norm_name] || ci_catalog[norm_name.downcase]
+      end
+
+      def ci_catalog
+        @ci_catalog ||= catalog.transform_keys(&:downcase)
+      end
+
+      def normalize_text_encoding(data)
+        return data if data.nil? || data.empty?
+
+        raw_b = data.b
+        if raw_b.start_with?("\xFF\xFE".b)
+          data.force_encoding(Encoding::UTF_16LE).encode(Encoding::UTF_8).delete_prefix("\uFEFF")
+        elsif raw_b.start_with?("\xFE\xFF".b)
+          data.force_encoding(Encoding::UTF_16BE).encode(Encoding::UTF_8).delete_prefix("\uFEFF")
+        elsif raw_b.start_with?("\xEF\xBB\xBF".b)
+          data.b.delete_prefix("\xEF\xBB\xBF".b).force_encoding(Encoding::UTF_8)
+        else
+          data.force_encoding(Encoding::UTF_8)
+        end
+      end
+
+      #: (String extra_data, Integer usize, Integer csize, Integer offset) -> [Integer, Integer, Integer]
+      def parse_zip64_extra(extra_data, usize, csize, offset)
+        pos = 0
+        len = extra_data.bytesize
+        while pos + 4 <= len
+          header_id, data_size = extra_data.byteslice(pos, 4).unpack("vv")
+          pos += 4
+          if header_id == 0x0001
+            field_data = extra_data.byteslice(pos, data_size)
+            if field_data
+              fpos = 0
+              if usize == 0xFFFF_FFFF && fpos + 8 <= field_data.bytesize
+                usize = field_data.byteslice(fpos, 8).unpack1("Q<")
+                fpos += 8
+              end
+              if csize == 0xFFFF_FFFF && fpos + 8 <= field_data.bytesize
+                csize = field_data.byteslice(fpos, 8).unpack1("Q<")
+                fpos += 8
+              end
+              offset = field_data.byteslice(fpos, 8).unpack1("Q<") if offset == 0xFFFF_FFFF && fpos + 8 <= field_data.bytesize
+            end
+            break
+          end
+          pos += data_size
+        end
+        [usize, csize, offset]
+      end
     end
   end
 end