xlsxrb 0.1.13 → 0.1.14

data/lib/xlsxrb/number_formatter.rb

@@ -0,0 +1,429 @@
+# frozen_string_literal: true
+
+# rbs_inline: enabled
+
+require "date"
+require "time"
+
+module Xlsxrb
+  # Formats cell values according to OpenXML formatCode strings.
+  # Evaluates and converts numeric, currency, percentage, date/time, scientific,
+  # and accounting format patterns into string representations.
+  #
+  # @api public
+  module NumberFormatter
+    # Built-in date and time format code strings.
+    DATE_PATTERNS = [
+      "mm-dd-yy", "d-mmm-yy", "d-mmm", "mmm-yy", "h:mm AM/PM", "h:mm:ss AM/PM", "h:mm", "h:mm:ss", "m/d/yy h:mm", "mm:ss", "[h]:mm:ss", "mmss.0"
+    ].freeze
+
+    class << self
+      # Formats a cell value according to an Excel format code string.
+      #
+      # @param value [Object, nil] The cell's raw or typed value.
+      # @param format_code [String, nil] Excel format code pattern.
+      # @param date1904 [Boolean] Whether the 1904 date system is active.
+      # @return [String] Formatted string representation.
+      # @api public
+      #: (untyped value, ?String? format_code, ?date1904: bool) -> String
+      def format(value, format_code = nil, date1904: false)
+        return "" if value.nil?
+        return value.code.to_s if value.respond_to?(:code)
+        return value ? "TRUE" : "FALSE" if [true, false].include?(value)
+
+        code = format_code.to_s.strip
+        return default_format(value) if code.empty? || code.casecmp("general").zero?
+
+        return format_datetime(value, code) if value.is_a?(Date) || value.is_a?(DateTime) || value.is_a?(Time)
+
+        if value.is_a?(Numeric) && date_format?(code)
+          dt = if value.is_a?(Float) && (value % 1).positive?
+                 Ooxml::Utils.serial_to_datetime(value, date1904: date1904)
+               else
+                 Ooxml::Utils.serial_to_date(value.to_i, date1904: date1904)
+               end
+          return format_datetime(dt, code)
+        end
+
+        return format_number(value, code) if value.is_a?(Numeric)
+
+        if code.include?("@")
+          sections = split_sections(code)
+          pattern = sections[3] || sections[0]
+          pattern.gsub("@", value.to_s)
+        else
+          value.to_s
+        end
+      end
+
+      # Resolves the format code string for a given style index from a styles definition hash.
+      #
+      # @param style_index [Integer, nil] 0-based style index in cellXfs.
+      # @param styles [Hash, nil] Parsed styles hash.
+      # @return [String, nil] Format code string, or nil if not found.
+      # @api public
+      #: (Integer? style_index, untyped styles) -> String?
+      def format_code_for(style_index, styles)
+        return nil unless style_index && styles
+        return styles.number_format(style_index) if styles.respond_to?(:number_format)
+
+        cell_xfs = styles[:cell_xfs]
+        return nil unless cell_xfs.is_a?(Array) && style_index < cell_xfs.size
+
+        xf = cell_xfs[style_index]
+        return nil unless xf.is_a?(Hash)
+
+        num_fmt_id = xf[:num_fmt_id]
+        if (num_fmt_id.nil? || num_fmt_id.zero?) && xf[:xf_id] && styles[:cell_style_xfs].is_a?(Array)
+          parent_xf = styles[:cell_style_xfs][xf[:xf_id]]
+          num_fmt_id = parent_xf[:num_fmt_id] if parent_xf.is_a?(Hash)
+        end
+
+        return nil unless num_fmt_id
+
+        num_fmts = styles[:num_fmts] || {}
+        num_fmts[num_fmt_id] || Ooxml::Utils::BUILTIN_NUM_FMT_CODES[num_fmt_id]
+      end
+
+      # Returns the classified format category for a format code string.
+      #
+      # @param format_code [String, nil] Format code string.
+      # @return [Symbol, nil] :date, :datetime, :time, :number, :text, :general, or nil.
+      # @api public
+      #: (String? format_code) -> Symbol?
+      def format_type(format_code)
+        return nil if format_code.nil?
+
+        code = format_code.to_s.strip
+        return :general if code.empty? || code.casecmp("general").zero?
+        return :text if code == "@"
+
+        case code
+        when "mm-dd-yy", "d-mmm-yy", "d-mmm", "mmm-yy", "yyyy\\-mm\\-dd", "yyyy-mm-dd", "m/d/yy", "m/d/yyyy"
+          return :date
+        when "m/d/yy h:mm", "m/d/yyyy h:mm", "yyyy\\-mm\\-dd\\ hh:mm:ss", "yyyy-mm-dd hh:mm:ss"
+          return :datetime
+        when "h:mm AM/PM", "h:mm:ss AM/PM", "h:mm", "h:mm:ss", "mm:ss", "[h]:mm:ss", "mmss.0"
+          return :time
+        end
+
+        stripped = code.gsub(/"[^"]*"/, "")
+                       .gsub(/\\[.]/, "")
+                       .gsub(/\[(?!h\]|m\]|s\]|hh\]|mm\]|ss\])[^\]]*\]/i, "")
+
+        has_date = stripped.match?(/[ydYD]/) || (stripped.match?(/[mM]/) && !stripped.match?(/[hsHS]/))
+        has_time = stripped.match?(/[hsHS]/)
+
+        if has_date && has_time
+          :datetime
+        elsif has_date
+          :date
+        elsif has_time
+          :time
+        elsif stripped.include?("@")
+          :text
+        else
+          :number
+        end
+      end
+
+      # Checks whether a format code string represents a date, datetime, or time pattern.
+      #
+      # @param format_code [String, nil]
+      # @param num_fmt_id [Integer, nil]
+      # @return [Boolean]
+      #: (String? format_code, ?Integer? num_fmt_id) -> bool
+      def date_format?(format_code, num_fmt_id = nil)
+        code = format_code
+        code = Ooxml::Utils::BUILTIN_NUM_FMT_CODES[num_fmt_id] if (code.nil? || code.empty?) && num_fmt_id
+        return false if code.nil? || code.empty?
+
+        type = format_type(code)
+        %i[date datetime time].include?(type)
+      end
+
+      # Checks whether a format code string represents a date-only pattern.
+      #
+      # @param format_code [String, nil]
+      # @param num_fmt_id [Integer, nil]
+      # @return [Boolean]
+      # @api public
+      #: (String? format_code, ?Integer? num_fmt_id) -> bool
+      def date_only_format?(format_code, num_fmt_id = nil)
+        code = format_code
+        code = Ooxml::Utils::BUILTIN_NUM_FMT_CODES[num_fmt_id] if (code.nil? || code.empty?) && num_fmt_id
+        return false if code.nil? || code.empty?
+
+        format_type(code) == :date
+      end
+
+      # Checks whether a format code string represents a datetime pattern.
+      #
+      # @param format_code [String, nil]
+      # @param num_fmt_id [Integer, nil]
+      # @return [Boolean]
+      # @api public
+      #: (String? format_code, ?Integer? num_fmt_id) -> bool
+      def datetime_format?(format_code, num_fmt_id = nil)
+        code = format_code
+        code = Ooxml::Utils::BUILTIN_NUM_FMT_CODES[num_fmt_id] if (code.nil? || code.empty?) && num_fmt_id
+        return false if code.nil? || code.empty?
+
+        format_type(code) == :datetime
+      end
+
+      # Checks whether a format code string represents a time-only pattern.
+      #
+      # @param format_code [String, nil]
+      # @param num_fmt_id [Integer, nil]
+      # @return [Boolean]
+      # @api public
+      #: (String? format_code, ?Integer? num_fmt_id) -> bool
+      def time_format?(format_code, num_fmt_id = nil)
+        code = format_code
+        code = Ooxml::Utils::BUILTIN_NUM_FMT_CODES[num_fmt_id] if (code.nil? || code.empty?) && num_fmt_id
+        return false if code.nil? || code.empty?
+
+        format_type(code) == :time
+      end
+
+      # Returns the format category Symbol for a style index and styles definition.
+      #
+      # @param style_index [Integer, nil]
+      # @param styles [untyped]
+      # @return [Symbol, nil]
+      # @api public
+      #: (Integer? style_index, untyped styles) -> Symbol?
+      def format_type_for(style_index, styles)
+        return styles.format_type(style_index) if styles.respond_to?(:format_type)
+
+        code = format_code_for(style_index, styles)
+        format_type(code)
+      end
+
+      # Checks whether a style index represents a date, datetime, or time format.
+      #
+      # @param style_index [Integer, nil]
+      # @param styles [untyped]
+      # @return [Boolean]
+      # @api public
+      #: (Integer? style_index, untyped styles) -> bool
+      def date_format_for?(style_index, styles)
+        return styles.date_format?(style_index) if styles.respond_to?(:date_format?)
+
+        code = format_code_for(style_index, styles)
+        date_format?(code)
+      end
+
+      # Checks whether a style index represents a datetime format.
+      #
+      # @param style_index [Integer, nil]
+      # @param styles [untyped]
+      # @return [Boolean]
+      # @api public
+      #: (Integer? style_index, untyped styles) -> bool
+      def datetime_format_for?(style_index, styles)
+        return styles.datetime_format?(style_index) if styles.respond_to?(:datetime_format?)
+
+        code = format_code_for(style_index, styles)
+        datetime_format?(code)
+      end
+
+      # Checks whether a style index represents a time format.
+      #
+      # @param style_index [Integer, nil]
+      # @param styles [untyped]
+      # @return [Boolean]
+      # @api public
+      #: (Integer? style_index, untyped styles) -> bool
+      def time_format_for?(style_index, styles)
+        return styles.time_format?(style_index) if styles.respond_to?(:time_format?)
+
+        code = format_code_for(style_index, styles)
+        time_format?(code)
+      end
+
+      # Checks whether a style index represents a date-only format.
+      #
+      # @param style_index [Integer, nil]
+      # @param styles [untyped]
+      # @return [Boolean]
+      # @api public
+      #: (Integer? style_index, untyped styles) -> bool
+      def date_only_format_for?(style_index, styles)
+        return styles.date_only_format?(style_index) if styles.respond_to?(:date_only_format?)
+
+        code = format_code_for(style_index, styles)
+        date_only_format?(code)
+      end
+
+      private
+
+      def default_format(value)
+        if value.is_a?(Float)
+          value == value.to_i ? value.to_i.to_s : value.to_s
+        else
+          value.to_s
+        end
+      end
+
+      def split_sections(code)
+        sections = []
+        current = String.new
+        in_quotes = false
+        code.each_char do |ch|
+          if ch == "\""
+            in_quotes = !in_quotes
+            current << ch
+          elsif ch == ";" && !in_quotes
+            sections << current
+            current = String.new
+          else
+            current << ch
+          end
+        end
+        sections << current
+        sections
+      end
+
+      def format_number(value, code)
+        sections = split_sections(code)
+        if sections.size == 1
+          pattern = sections[0]
+          is_negative = value.negative?
+          num = value.abs
+        elsif sections.size >= 2
+          if value.negative?
+            pattern = sections[1]
+            is_negative = false
+            num = value.abs
+          elsif value.zero? && sections.size >= 3
+            pattern = sections[2]
+            is_negative = false
+            num = 0
+          else
+            pattern = sections[0]
+            is_negative = false
+            num = value
+          end
+        end
+
+        return (is_negative ? "-#{num}" : num.to_s) if pattern == "@"
+
+        format_single_number(num, pattern, is_negative)
+      end
+
+      def format_single_number(num, pattern, is_neg)
+        clean = pattern.strip
+        prefix = ""
+        suffix = ""
+
+        if clean =~ /\A\\-/ || clean =~ /\A-/
+          prefix = "-"
+          clean = clean.sub(/\A\\-/, "").sub(/\A-/, "")
+        end
+
+        clean = clean.gsub(/_[-_()€$]/, "").gsub(/\* */, "").gsub("\\ ", "").gsub(/"[^"]*"/, "").strip if clean.include?("_-") || clean.include?("*-") || clean.include?("* ")
+
+        case clean
+        when /\A(\[Red\])?\((.*)\)\z/
+          prefix = "#{::Regexp.last_match(1)}("
+          suffix = ")"
+          clean = ::Regexp.last_match(2)
+        when /\A"([^"]+)"(.*)\z/, /\A\[\$([^\]-]+)[^\]]*\]\s*(.*)\z/, /\A([$€£¥])(.*)\z/
+          prefix = ::Regexp.last_match(1)
+          clean = ::Regexp.last_match(2)
+        end
+
+        if clean =~ /0\.0+E\+00/i
+          dec = clean[/0\.(0+)E/i, 1].size
+          formatted = Kernel.format("%.#{dec}E", num)
+          return "#{prefix}#{formatted}#{suffix}"
+        elsif clean =~ /##0\.0+E\+0/i
+          dec = clean[/##0\.(0+)E/i, 1].size
+          formatted = Kernel.format("%.#{dec}E", num)
+          return "#{prefix}#{formatted}#{suffix}"
+        end
+
+        if clean.end_with?("%")
+          clean = clean.sub(/%+\z/, "")
+          suffix = "%#{suffix}"
+          num = num.to_f * 100
+        end
+
+        if clean =~ /\A(0+)\z/
+          zeros = ::Regexp.last_match(1).size
+          formatted = Kernel.format("%0#{zeros}d", num.round)
+          return "#{"-" if is_neg}#{prefix}#{formatted}#{suffix}"
+        end
+
+        decimals = 0
+        decimals = ::Regexp.last_match(1).size if clean =~ /\.(0+)/
+
+        has_commas = clean.include?(",")
+
+        str = Kernel.format("%.#{decimals}f", num)
+        if has_commas
+          parts = str.split(".")
+          parts[0] = parts[0].reverse.gsub(/(\d{3})(?=\d)/, "\\1,").reverse
+          str = parts.join(".")
+        end
+
+        "#{"-" if is_neg}#{prefix}#{str}#{suffix}"
+      end
+
+      def format_datetime(datetime, format_code)
+        strftime_pattern = excel_to_strftime(format_code)
+        datetime.strftime(strftime_pattern)
+      rescue StandardError
+        datetime.strftime("%Y-%m-%d %H:%M:%S")
+      end
+
+      def excel_to_strftime(format_code)
+        code = format_code.dup
+
+        code.gsub!(%r{am/pm}i, "%p")
+        code.gsub!(%r{a/p}i, "%p")
+
+        code.gsub!(/\[h+\]/i, "[%-k]")
+
+        code.gsub!(/(h+:)(mm)/i, "\\1%M")
+        code.gsub!(/(h+:)(m)(?!%)/i, "\\1%-M")
+        code.gsub!(/(mm)(:s+)/i, "%M\\2")
+        code.gsub!(/(?<!%)(m)(:s+)/i, "%-M\\2")
+
+        code.gsub!(/ss/i, "%S")
+        code.gsub!(/(?<!%)s/i, "%-S")
+
+        code.gsub!("000", "%3N")
+        code.gsub!("00", "%2N")
+        code.gsub!("0", "%1N")
+
+        code.gsub!(/mmmm/i, "%B")
+        code.gsub!(/mmm/i, "%^b")
+        code.gsub!(/mm/i, "%m")
+        code.gsub!(/(?<!%)(?<![a-zA-Z])m(?![a-zA-Z])/i, "%-m")
+
+        if code.include?("%p")
+          code.gsub!(/hh/i, "%I")
+          code.gsub!(/(?<!%)h/i, "%-l")
+        else
+          code.gsub!(/hh/i, "%H")
+          code.gsub!(/(?<!%)h/i, "%-k")
+        end
+
+        code.gsub!(/dddd/i, "%A")
+        code.gsub!(/ddd/i, "%^a")
+        code.gsub!(/dd/i, "%d")
+        code.gsub!(/(?<!%)d/i, "%-d")
+
+        code.gsub!(/yyyy/i, "%Y")
+        code.gsub!(/yy/i, "%y")
+
+        code.gsub!(/\\(.)/, "\\1")
+
+        code
+      end
+    end
+  end
+end

data/lib/xlsxrb/ooxml/cfb.rb

@@ -63,7 +63,7 @@ module Xlsxrb
         def self.cfb?(data)
           case data
           when String
-            data.start_with?(MAGIC)
+            data.b.start_with?(MAGIC)
           else
             false
           end

data/lib/xlsxrb/ooxml/reader/listeners/core_listeners.rb

@@ -292,11 +292,11 @@ module Xlsxrb
 
           attrs = {}
           ht = attributes["ht"]
-          attrs[:height] = ht.to_f if ht && attributes["customHeight"] == "1"
-          attrs[:hidden] = true if attributes["hidden"] == "1"
+          attrs[:height] = ht.to_f if ht && %w[1 true].include?(attributes["customHeight"])
+          attrs[:hidden] = true if %w[1 true].include?(attributes["hidden"])
           ol = attributes["outlineLevel"]
           attrs[:outline_level] = ol.to_i if ol && ol != "0"
-          attrs[:collapsed] = true if attributes["collapsed"] == "1"
+          attrs[:collapsed] = true if %w[1 true].include?(attributes["collapsed"])
           s = attributes["s"]
           attrs[:style] = s.to_i if s
           attrs[:thick_top] = true if attributes["thickTop"] == "1"
@@ -401,7 +401,8 @@ module Xlsxrb
           when "workbook"
             @conformance = attributes["conformance"] if attributes["conformance"]
           when "sheet"
-            @sheets << { name: attributes["name"], rid: attributes["r:id"], state: attributes["state"] }
+            rid = attributes["r:id"] || attributes["id"] || attributes.find { |k, _| k.end_with?(":id") }&.last
+            @sheets << { name: attributes["name"], rid: rid, state: attributes["state"] }
           when "fileVersion"
             an = attributes["appName"]
             @file_version[:app_name] = an if an
@@ -736,7 +737,8 @@ module Xlsxrb
           return unless ref
 
           link = { ref: ref }
-          link[:rid] = attributes["r:id"] if attributes["r:id"]
+          rid = attributes["r:id"] || attributes["id"] || attributes.find { |k, _| k.end_with?(":id") }&.last
+          link[:rid] = rid if rid
           link[:display] = attributes["display"] if attributes["display"]
           link[:tooltip] = attributes["tooltip"] if attributes["tooltip"]
           link[:location] = attributes["location"] if attributes["location"]

data/lib/xlsxrb/ooxml/reader/listeners/drawing_listeners.rb

@@ -51,7 +51,7 @@ module Xlsxrb
               @current_image[:hidden] = %w[1 true].include?(attributes["hidden"]) if attributes["hidden"]
             end
           when "blip"
-            rid = attributes["r:embed"] || attributes["embed"]
+            rid = attributes["r:embed"] || attributes["embed"] || attributes.find { |k, _| k.end_with?(":embed") }&.last
             @current_image[:embed_rid] = rid if @inside_pic && @current_image && rid
           when "alphaModFix"
             @current_image[:alpha_mod_fix] = attributes["amt"].to_i if @inside_pic && @current_image && attributes["amt"]
@@ -87,11 +87,14 @@ module Xlsxrb
           when "to"
             @inside_to = true if @inside_anchor
           when "ext"
+            cx = attributes["cx"]
+            cy = attributes["cy"]
             if @inside_pic && @current_image
-              cx = attributes["cx"]
-              cy = attributes["cy"]
               @current_image[:cx] = cx.to_i if cx
               @current_image[:cy] = cy.to_i if cy
+            elsif @inside_anchor
+              @anchor_cx = cx.to_i if cx
+              @anchor_cy = cy.to_i if cy
             end
           when "col", "colOff", "row", "rowOff"
             @current_field = name
@@ -116,6 +119,8 @@ module Xlsxrb
               @anchor_from.each { |k, v| @current_image[:"from_#{k}"] = v }
               @anchor_to.each { |k, v| @current_image[:"to_#{k}"] = v }
               @current_image[:edit_as] = @anchor_edit_as if @anchor_edit_as
+              @current_image[:cx] ||= @anchor_cx if @anchor_cx
+              @current_image[:cy] ||= @anchor_cy if @anchor_cy
               @images << @current_image
             end
             @current_image = nil
@@ -127,6 +132,8 @@ module Xlsxrb
             @inside_anchor = false
             @anchor_from = {}
             @anchor_to = {}
+            @anchor_cx = nil
+            @anchor_cy = nil
             @anchor_locks_with_sheet = nil
             @anchor_prints_with_sheet = nil
             @anchor_published = false
@@ -203,7 +210,7 @@ module Xlsxrb
               @current_chart[:frame_hidden] = %w[1 true].include?(attributes["hidden"]) if attributes["hidden"]
             end
           when "chart"
-            rid = attributes["r:id"] || attributes["id"]
+            rid = attributes["r:id"] || attributes["id"] || attributes.find { |k, _| k.end_with?(":id") }&.last
             @current_chart[:rid] = rid if @inside_graphic_frame && @current_chart && rid
           when "graphicFrameLocks"
             @current_chart[:frame_no_grp] = true if @inside_graphic_frame && @current_chart && %w[1 true].include?(attributes["noGrp"])

data/lib/xlsxrb/ooxml/reader.rb

@@ -89,18 +89,7 @@ module Xlsxrb
         return {} if worksheet_xml.nil? || worksheet_xml.empty?
 
         # Parse hyperlink elements from worksheet.
-        links = []
-        WorksheetParser.each_event(worksheet_xml, part_name: entry_path) do |event|
-          next unless event.type == :hyperlink
-
-          ref, rid, display, tooltip, location = event.args
-          link = { ref: ref }
-          link[:rid] = rid if rid
-          link[:display] = display if display
-          link[:tooltip] = tooltip if tooltip
-          link[:location] = location if location
-          links << link
-        end
+        links = WorksheetParser.parse_hyperlinks(worksheet_xml)
 
         # Parse rels to resolve rId -> URL.
         rels_path = entry_path.sub(%r{([^/]+)$}, '_rels/\1.rels')
@@ -554,6 +543,14 @@ module Xlsxrb
         parse_workbook_metadata[:workbook_properties]
       end
 
+      # Returns whether the workbook uses the 1904 date system.
+      #
+      # @return [Boolean]
+      #: () -> bool
+      def date1904?
+        workbook_properties&.[](:date1904) ? true : false
+      end
+
       # Returns the workbook conformance class ("transitional" or "strict"), or nil if not set.
       def conformance
         parse_workbook_metadata[:conformance]
@@ -1227,6 +1224,7 @@ module Xlsxrb
       end
 
       def resolve_date_cells(raw_cells, cell_style_map, styles)
+        is_date1904 = workbook_properties&.[](:date1904) || false
         raw_cells.each do |cell_ref, value|
           next unless value.is_a?(Numeric)
 
@@ -1240,9 +1238,9 @@ module Xlsxrb
           next unless date_format?(fmt_id, styles[:num_fmts])
 
           raw_cells[cell_ref] = if value.is_a?(Float) && (value % 1).positive?
-                                  Xlsxrb::Ooxml::Utils.serial_to_datetime(value)
+                                  Xlsxrb::Ooxml::Utils.serial_to_datetime(value, date1904: is_date1904)
                                 else
-                                  Xlsxrb::Ooxml::Utils.serial_to_date(value.to_i)
+                                  Xlsxrb::Ooxml::Utils.serial_to_date(value.to_i, date1904: is_date1904)
                                 end
         end
         raw_cells

data/lib/xlsxrb/ooxml/shared_strings_parser.rb

@@ -101,7 +101,7 @@ module Xlsxrb
             str = ""
           end
 
-          yield str.freeze
+          yield normalize_newlines(str).freeze
           pos = si_end + 5
         end
       end
@@ -134,6 +134,12 @@ module Xlsxrb
       end
 
       private_class_method :extract_multi_t
+
+      def self.normalize_newlines(str)
+        str.include?("\r") ? str.gsub("\r\n", "\n").tr("\r", "\n") : str
+      end
+
+      private_class_method :normalize_newlines
     end
   end
 end