xlsxrb 0.1.14 → 0.1.16

data/lib/xlsxrb/ooxml/worksheet_parser.rb

@@ -13,6 +13,7 @@ module Xlsxrb
     class WorksheetParser
       EMPTY_ARRAY = [].freeze
       EMPTY_HASH = {}.freeze
+      EMPTY_BINARY = "".b.freeze
       TAG_DELIM_BYTES = [32, 62, 9, 10, 13, 47].freeze
       ROW_ATTR_START_BYTES = [104, 99, 111, 115].freeze
 
@@ -214,10 +215,7 @@ module Xlsxrb
           tag_end = xml.index(">", row_start + row_start_len)
           break unless tag_end
 
-          if xml.getbyte(tag_end - 1) == 47
-            pos = tag_end + 1
-            next
-          end
+          is_self_closing = xml.getbyte(tag_end - 1) == 47
 
           # Row index and attrs from tag substring (bounded search)
           row_tag = xml.byteslice(row_start, tag_end - row_start)
@@ -227,9 +225,6 @@ module Xlsxrb
 
           attrs = extract_row_attrs(row_tag)
 
-          row_end = xml.index(row_end_tag, tag_end + 1)
-          break unless row_end
-
           row_source = { part: part_name, row: row_index }
           block.call(Event.new(
                        type: :row_start,
@@ -237,6 +232,19 @@ module Xlsxrb
                        source: row_source
                      ))
 
+          if is_self_closing
+            block.call(Event.new(
+                         type: :row_end,
+                         args: [],
+                         source: row_source
+                       ))
+            pos = tag_end + 1
+            next
+          end
+
+          row_end = xml.index(row_end_tag, tag_end + 1)
+          break unless row_end
+
           fast_scan_cells_events(xml, tag_end + 1, row_end, shared_strings, row_source, prefix, &block)
 
           block.call(Event.new(
@@ -431,60 +439,128 @@ module Xlsxrb
       private_class_method :fast_scan_cells_events
 
       def self.extract_inline_text(xml, from, to)
+        xml = xml.b
         result = +""
         pos = from
         while pos < to
-          t_start = xml.index("<", pos)
-          break unless t_start && t_start < to
+          tag_start = xml.index("<", pos)
+          break unless tag_start && tag_start < to
+
+          # Check self-closing tag or closing tag
+          next_byte = xml.getbyte(tag_start + 1)
+          if next_byte == 47 # </...
+            tag_end = xml.index(">", tag_start + 2)
+            break unless tag_end
 
-          t_term = xml.index("t", t_start)
-          break unless t_term && t_term < to
+            pos = tag_end + 1
+            next
+          end
 
-          t_tag_end = xml.index(">", t_term)
-          break unless t_tag_end && t_tag_end < to
+          tag_end = xml.index(">", tag_start + 1)
+          break unless tag_end && tag_end <= to
 
-          if xml.getbyte(t_tag_end - 1) == 47 # <t ... />
-            pos = t_tag_end + 1
+          # Skip self-closing tags (<.../>)
+          if xml.getbyte(tag_end - 1) == 47
+            pos = tag_end + 1
             next
           end
 
-          t_close = xml.index("</", t_tag_end + 1)
-          break unless t_close && t_close <= to
+          tag_header = xml.byteslice(tag_start + 1, tag_end - tag_start - 1)
+          tag_name = tag_header.split(/[ \t\r\n]/, 2).first || ""
+          tag_localname = tag_name.include?(":") ? tag_name.split(":", 2).last : tag_name
+
+          if tag_localname == "rPh"
+            # Skip phonetic readings
+            close_rph = xml.index("</#{tag_name}>", tag_end + 1) || xml.index("</rPh>", tag_end + 1)
+            break unless close_rph && close_rph < to
 
-          t_end = xml.index(">", t_close + 2)
-          break unless t_end && t_end <= to
+            close_end = xml.index(">", close_rph)
+            break unless close_end
 
-          text_segment = xml.byteslice(t_tag_end + 1, t_close - t_tag_end - 1).force_encoding("UTF-8")
-          result << normalize_text(text_segment)
+            pos = close_end + 1
+            next
+          elsif tag_localname == "t"
+            close_t = xml.index("</#{tag_name}>", tag_end + 1) || xml.index("</t>", tag_end + 1)
+            break unless close_t && close_t <= to
 
-          pos = t_end + 1
+            close_end = xml.index(">", close_t)
+            break unless close_end
+
+            text_segment = xml.byteslice(tag_end + 1, close_t - tag_end - 1).force_encoding("UTF-8")
+            result << normalize_text(text_segment)
+            pos = close_end + 1
+            next
+          else
+            pos = tag_end + 1
+          end
         end
         result
       end
 
       private_class_method :extract_inline_text
 
-      def self.resolve_fast_value(raw, type, shared_strings)
+      STRICT_NUMERIC_RE = /\A[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?\z/
+      private_constant :STRICT_NUMERIC_RE
+
+      # Resolves a cell value from its type attribute and parsed XML content (<v> or <is>).
+      # Consolidates parsing across fast-scan direct, row values, events, and listener paths.
+      #: (String? type, String? raw_value, String? is_xml, Array[String | Elements::RichText | untyped] shared_strings) -> untyped
+      def self.resolve_cell_value(type, raw_value, is_xml, shared_strings)
         case type
         when "s"
-          shared_strings[raw.to_i] || ""
+          raw_value ? (shared_strings[raw_value.to_i] || "") : nil
         when "b"
-          raw == "1"
-        when "e", "str", "inlineStr"
-          normalize_text(raw.force_encoding("UTF-8"))
+          if raw_value
+            v = raw_value.strip
+            v == "1" || v.casecmp?("true")
+          end
+        when "inlineStr", "str", "e"
+          if is_xml
+            extract_inline_text(is_xml, 0, is_xml.bytesize)
+          elsif raw_value
+            normalize_text(raw_value)
+          end
+        when "d"
+          raw_value && normalize_text(raw_value)
+        when "n"
+          raw_value ? numeric_cell_value(raw_value) : nil
         else
-          return nil if raw.empty?
-
-          if raw.include?(".")
-            raw.to_f
-          else
-            raw.to_i
+          if raw_value
+            text = raw_value.strip
+            return nil if text.empty?
+
+            if text.match?(STRICT_NUMERIC_RE)
+              Integer(text, 10, exception: false) ||
+                Float(text, exception: false) ||
+                normalize_text(raw_value)
+            else
+              normalize_text(raw_value)
+            end
           end
         end
       end
 
+      def self.resolve_fast_value(raw, type, shared_strings)
+        resolve_cell_value(type, raw, nil, shared_strings)
+      end
+
       private_class_method :resolve_fast_value
 
+      # Converts the text of a numeric cell (<c t="n">) into an Integer or Float.
+      # An empty <v></v> carries no value and yields nil. Text that is not an xsd:double
+      # (e.g. "abc") cannot come from a conforming producer and raises ParseError
+      # instead of silently becoming 0.
+      #: (String raw) -> (Integer | Float)?
+      def self.numeric_cell_value(raw)
+        text = raw.strip
+        return nil if text.empty?
+
+        raise(ParseError, "invalid numeric cell value: #{text.inspect}") unless text.match?(STRICT_NUMERIC_RE)
+
+        Integer(text, 10, exception: false) || Float(text, exception: false) ||
+          raise(ParseError, "invalid numeric cell value: #{text.inspect}")
+      end
+
       # SECURITY NOTE: Decodes only standard predefined XML entities in a single pass.
       # This completely prevents "Billion Laughs" attacks (exponential entity expansion)
       # because it avoids recursive expansion and ignores custom entities entirely.
@@ -496,7 +572,8 @@ module Xlsxrb
       #: (String str) -> String
       def self.normalize_text(str)
         s = decode_xml_entities(str)
-        s.include?("\r") ? s.gsub("\r\n", "\n").tr("\r", "\n") : s
+        s = s.gsub("\r\n", "\n").tr("\r", "\n") if s.include?("\r")
+        s.encoding == Encoding::BINARY ? s.dup.force_encoding(Encoding::UTF_8) : s
       end
 
       # Parses <cols> section for column definitions.
@@ -579,10 +656,7 @@ module Xlsxrb
           tag_end = xml.index(">", row_start + row_start_len)
           break unless tag_end
 
-          if xml.getbyte(tag_end - 1) == 47
-            pos = tag_end + 1
-            next
-          end
+          is_self_closing = xml.getbyte(tag_end - 1) == 47
 
           row_index = nil
           has_custom_attrs = false
@@ -618,6 +692,29 @@ module Xlsxrb
                     EMPTY_HASH
                   end
 
+          if is_self_closing
+            row_obj = StreamRow.fast_create(
+              row_index,
+              EMPTY_BINARY,
+              0,
+              0,
+              shared_strings,
+              prefix,
+              attrs[:height],
+              attrs[:hidden] || false,
+              attrs[:custom_height] || false,
+              attrs[:outline_level],
+              attrs[:style_index],
+              styles,
+              date1904,
+              attrs[:collapsed] || false,
+              pad_empty_cells
+            )
+            block.call(row_obj)
+            pos = tag_end + 1
+            next
+          end
+
           row_end = xml.index(row_end_tag, tag_end + 1)
           break unless row_end
 
@@ -726,17 +823,15 @@ module Xlsxrb
             tag_end = buffer.index(">", next_pos)
             break if tag_end.nil?
 
-            if buffer.getbyte(tag_end - 1) == 47
-              pos = tag_end + 1
-              last_consumed_pos = pos
-              next
-            end
+            is_self_closing = buffer.getbyte(tag_end - 1) == 47
 
-            row_end = buffer.index(row_end_tag, tag_end + 1)
-            if row_end.nil?
-              raise ArgumentError, "Malformed XML: row size exceeds maximum buffer limit" if buffer.bytesize > 50 * 1024 * 1024
+            unless is_self_closing
+              row_end = buffer.index(row_end_tag, tag_end + 1)
+              if row_end.nil?
+                raise ArgumentError, "Malformed XML: row size exceeds maximum buffer limit" if buffer.bytesize > 50 * 1024 * 1024
 
-              break
+                break
+              end
             end
 
             row_index = nil
@@ -773,6 +868,30 @@ module Xlsxrb
                       EMPTY_HASH
                     end
 
+            if is_self_closing
+              row_obj = StreamRow.fast_create(
+                row_index,
+                EMPTY_BINARY,
+                0,
+                0,
+                shared_strings,
+                prefix,
+                attrs[:height],
+                attrs[:hidden] || false,
+                attrs[:custom_height] || false,
+                attrs[:outline_level],
+                attrs[:style_index],
+                styles,
+                date1904,
+                attrs[:collapsed] || false,
+                pad_empty_cells
+              )
+              block.call(row_obj)
+              pos = tag_end + 1
+              last_consumed_pos = pos
+              next
+            end
+
             cells_xml = buffer.byteslice(tag_end + 1, row_end - (tag_end + 1))
             row_obj = StreamRow.fast_create(
               row_index,
@@ -846,11 +965,11 @@ module Xlsxrb
         [COL_LETTERS[idx], idx]
       end.freeze
 
-      CELL_FAST_RE = %r{<(?:[a-zA-Z0-9_]+:)?c\s+r="([A-Za-z0-9]+)"(?:[^>]*?s="(\d+)")?(?:[^>]*?t="([a-zA-Z]+)")?[^>]*>\s*(?:<(?:[a-zA-Z0-9_]+:)?f\b[^>]*?(?:/>|>([^<]*)</(?:[a-zA-Z0-9_]+:)?f>)\s*)?(?:<(?:[a-zA-Z0-9_]+:)?v>([^<]*)</(?:[a-zA-Z0-9_]+:)?v>\s*)?(?:<(?:[a-zA-Z0-9_]+:)?is>(.*?)</(?:[a-zA-Z0-9_]+:)?is>\s*)?.*?</(?:[a-zA-Z0-9_]+:)?c>|<(?:[a-zA-Z0-9_]+:)?c\s+r="([A-Za-z0-9]+)"(?:[^>]*?s="(\d+)")?[^>]*/>}m
+      CELL_FAST_RE = %r{<(?:[a-zA-Z0-9_]+:)?c\b([^>]*(?<!/))>\s*(?:<(?:[a-zA-Z0-9_]+:)?f\b[^>]*?(?:/>|>([^<]*)</(?:[a-zA-Z0-9_]+:)?f>)\s*)?(?:<(?:[a-zA-Z0-9_]+:)?v>([^<]*)</(?:[a-zA-Z0-9_]+:)?v>\s*)?(?:<(?:[a-zA-Z0-9_]+:)?is>(.*?)</(?:[a-zA-Z0-9_]+:)?is>\s*)?.*?</(?:[a-zA-Z0-9_]+:)?c>|<(?:[a-zA-Z0-9_]+:)?c\b([^>]*)/?>}m
       CELL_GENERIC_RE = %r{<(?:[a-zA-Z0-9_]+:)?c\b([^>]*?)(?:>\s*(?:<(?:[a-zA-Z0-9_]+:)?f\b[^>]*?(?:/>|>([^<]*)</(?:[a-zA-Z0-9_]+:)?f>)\s*)?(?:<(?:[a-zA-Z0-9_]+:)?v>([^<]*)</(?:[a-zA-Z0-9_]+:)?v>\s*)?(?:<(?:[a-zA-Z0-9_]+:)?is>(.*?)</(?:[a-zA-Z0-9_]+:)?is>\s*)?.*?</(?:[a-zA-Z0-9_]+:)?c>|/>)}m
-      ATTR_R = /r="([A-Za-z0-9]+)"/
-      ATTR_T = /t="([a-zA-Z]+)"/
-      ATTR_S = /s="(\d+)"/
+      ATTR_R = /\br="([A-Za-z0-9]+)"/
+      ATTR_T = /\bt="([a-zA-Z]+)"/
+      ATTR_S = /\bs="(\d+)"/
 
       def self.fast_parse_cells_direct(xml, from, to, shared_strings, row_source, prefix = "")
         cells = []
@@ -866,14 +985,17 @@ module Xlsxrb
         col_idx = 0
         matched_any = false
 
-        chunk.scan(CELL_FAST_RE) do |r, s, t, f, v, is, self_r, self_s|
+        chunk.scan(CELL_FAST_RE) do |attrs_str, f, v, is, self_attrs|
           matched_any = true
-          ref = r || self_r
-          s_val = s || self_s
-          style_idx = s_val&.to_i
+          raw_attrs = attrs_str || self_attrs || ""
+          r = raw_attrs[ATTR_R, 1]
+          s = raw_attrs.include?('s="') ? raw_attrs[ATTR_S, 1] : nil
+          t = raw_attrs.include?('t="') ? raw_attrs[ATTR_T, 1] : nil
+          style_idx = s&.to_i
+          ref = r
           c_idx = if ref
                     expected_letter = COL_LETTERS[col_idx]
-                    if expected_letter && ref.start_with?(expected_letter)
+                    if expected_letter && ref.start_with?(expected_letter) && ref.getbyte(expected_letter.bytesize)&.between?(48, 57)
                       col_idx
                     else
                       c_len = 0
@@ -888,21 +1010,7 @@ module Xlsxrb
           v = v.strip if v
           f = f.strip if f
 
-          val = if t == "s"
-                  shared_strings[v.to_i] || ""
-                elsif t == "b"
-                  v == "1"
-                elsif %w[inlineStr str e].include?(t)
-                  if is
-                    extract_inline_text(is, 0, is.bytesize)
-                  elsif v
-                    normalize_text(v)
-                  else
-                    ""
-                  end
-                elsif v
-                  v.include?(".") ? v.to_f : v.to_i
-                end
+          val = resolve_cell_value(t, v, is, shared_strings)
 
           raw_val = if is
                       extract_inline_text(is, 0, is.bytesize)
@@ -927,7 +1035,7 @@ module Xlsxrb
 
           c_idx = if r
                     expected_letter = COL_LETTERS[col_idx]
-                    if expected_letter && r.start_with?(expected_letter)
+                    if expected_letter && r.start_with?(expected_letter) && r.getbyte(expected_letter.bytesize)&.between?(48, 57)
                       col_idx
                     else
                       c_len = 0
@@ -942,21 +1050,7 @@ module Xlsxrb
           v = v.strip if v
           f = f.strip if f
 
-          val = if t == "s"
-                  shared_strings[v.to_i] || ""
-                elsif t == "b"
-                  v == "1"
-                elsif %w[inlineStr str e].include?(t)
-                  if is
-                    extract_inline_text(is, 0, is.bytesize)
-                  elsif v
-                    normalize_text(v)
-                  else
-                    ""
-                  end
-                elsif v
-                  v.include?(".") ? v.to_f : v.to_i
-                end
+          val = resolve_cell_value(t, v, is, shared_strings)
 
           raw_val = if is
                       extract_inline_text(is, 0, is.bytesize)
@@ -974,7 +1068,7 @@ module Xlsxrb
       end
 
       # rubocop:disable Style/OptionalBooleanParameter
-      #: (String xml, Integer from, Integer to, Array[String] shared_strings, ?untyped styles, ?bool date1904, ?type_cast: bool) -> Array[untyped]
+      #: (String xml, Integer from, Integer to, Array[String | Elements::RichText | untyped] shared_strings, ?untyped styles, ?bool date1904, ?type_cast: bool) -> Array[untyped]
       def self.fast_scan_row_values(xml, from, to, shared_strings, styles = nil, date1904 = false, type_cast: false)
         # rubocop:enable Style/OptionalBooleanParameter
         chunk = xml.byteslice(from, to - from)
@@ -984,13 +1078,16 @@ module Xlsxrb
         matched_any = false
         row_values = []
 
-        chunk.scan(CELL_FAST_RE) do |r, s, t, _f, v, is, self_r, self_s|
+        chunk.scan(CELL_FAST_RE) do |attrs_str, _f, v, is, self_attrs|
           matched_any = true
-          ref = r || self_r
-          s_val = s || self_s
+          raw_attrs = attrs_str || self_attrs || ""
+          r = raw_attrs[ATTR_R, 1]
+          s_val = raw_attrs.include?('s="') ? raw_attrs[ATTR_S, 1] : nil
+          t = raw_attrs.include?('t="') ? raw_attrs[ATTR_T, 1] : nil
+          ref = r
           c_idx = if ref
                     expected_letter = COL_LETTERS[col_idx]
-                    if expected_letter && ref.start_with?(expected_letter)
+                    if expected_letter && ref.start_with?(expected_letter) && ref.getbyte(expected_letter.bytesize)&.between?(48, 57)
                       col_idx
                     else
                       c_len = 0
@@ -1004,21 +1101,7 @@ module Xlsxrb
           col_idx = c_idx + 1
           v = v.strip if v
 
-          val = if t == "s"
-                  shared_strings[v.to_i] || ""
-                elsif t == "b"
-                  v == "1"
-                elsif %w[inlineStr str e].include?(t)
-                  if is
-                    extract_inline_text(is, 0, is.bytesize)
-                  elsif v
-                    normalize_text(v)
-                  else
-                    ""
-                  end
-                elsif v
-                  v.include?(".") ? v.to_f : v.to_i
-                end
+          val = resolve_cell_value(t, v, is, shared_strings)
 
           if type_cast && val.is_a?(Numeric) && s_val && styles
             fmt_type = NumberFormatter.format_type_for(s_val.to_i, styles)
@@ -1047,7 +1130,7 @@ module Xlsxrb
 
           c_idx = if r
                     expected_letter = COL_LETTERS[col_idx]
-                    if expected_letter && r.start_with?(expected_letter)
+                    if expected_letter && r.start_with?(expected_letter) && r.getbyte(expected_letter.bytesize)&.between?(48, 57)
                       col_idx
                     else
                       c_len = 0
@@ -1061,21 +1144,7 @@ module Xlsxrb
           col_idx = c_idx + 1
           v = v.strip if v
 
-          val = if t == "s"
-                  shared_strings[v.to_i] || ""
-                elsif t == "b"
-                  v == "1"
-                elsif %w[inlineStr str e].include?(t)
-                  if is
-                    extract_inline_text(is, 0, is.bytesize)
-                  elsif v
-                    normalize_text(v)
-                  else
-                    ""
-                  end
-                elsif v
-                  v.include?(".") ? v.to_f : v.to_i
-                end
+          val = resolve_cell_value(t, v, is, shared_strings)
 
           if type_cast && val.is_a?(Numeric) && s && styles
             fmt_type = NumberFormatter.format_type_for(s.to_i, styles)