xlsxrb 0.1.14 → 0.1.15

data/lib/xlsxrb/ooxml/worksheet_writer.rb

@@ -47,7 +47,7 @@ module Xlsxrb
       #   split_pane: { x_split:, y_split:, top_left_cell: }
       #   selection: { active_cell:, sqref:, pane: }
       #   sheet_view: Hash of sheet view properties
-      def start(columns: [], sheet_properties: nil, freeze_pane: nil, split_pane: nil, selection: nil, sheet_view: nil)
+      def start(columns: [], sheet_properties: nil, freeze_pane: nil, split_pane: nil, selection: nil, sheet_view: nil, sheet_format: nil)
         return if @started
 
         @started = true
@@ -75,6 +75,7 @@ module Xlsxrb
 
         write_sheet_properties(sheet_properties) if sheet_properties && !sheet_properties.empty?
         write_sheet_views(freeze_pane: freeze_pane, split_pane: split_pane, selection: selection, sheet_view: sheet_view) if freeze_pane || split_pane || selection || (sheet_view && !sheet_view.empty?)
+        write_sheet_format_pr(sheet_format) if sheet_format && !sheet_format.empty?
         write_columns(columns) unless columns.empty?
 
         @builder.open_tag("sheetData")
@@ -88,7 +89,7 @@ module Xlsxrb
         row_num_str = row_num.to_s
         buf = @row_buffer ||= String.new(capacity: 65_536)
         buf << '<row r="' << row_num_str << '"'
-        buf << ' s="' << attrs[:style_index].to_s << '" customFormat="1"' if attrs[:style_index]
+        buf << ' s="' << attrs[:style_index].to_s << '" customFormat="1"' if attrs[:style_index].is_a?(Integer)
         if attrs[:height]
           buf << ' ht="' << attrs[:height].to_s << '" customHeight="1"'
         elsif attrs[:custom_height]
@@ -128,6 +129,7 @@ module Xlsxrb
 
           col_style = @column_styles && col_idx ? @column_styles[col_idx] : nil
           style_id ||= attrs[:style_index] || col_style
+          style_id = nil unless style_id.is_a?(Integer)
 
           # Fast path for common unstyled cells
           if !formula && !style_id && !cell_type_val
@@ -425,8 +427,7 @@ module Xlsxrb
         end
 
         is_styles_collection = styles && (styles.is_a?(Array) || styles.is_a?(Hash))
-        single_style_id = nil
-        single_style_id = style_map[styles] if styles && style_map && !is_styles_collection
+        single_style_id = resolve_style_id(styles, style_map) unless is_styles_collection
 
         buf << '<row r="' << row_num_str << '"'
         if attrs
@@ -444,7 +445,7 @@ module Xlsxrb
         end
 
         row_style = attrs ? attrs[:style_index] : nil
-        row_style_id = row_style && style_map ? (style_map[row_style] || style_map[row_style.to_s] || row_style) : row_style
+        row_style_id = resolve_style_id(row_style, style_map)
 
         col_index = 0
         while col_index < max_len
@@ -456,20 +457,12 @@ module Xlsxrb
                          else
                            styles[col_index]
                          end
-            style_id = if style_map && style_name
-                         style_map[style_name] || style_map[style_name.to_s] || style_name
-                       else
-                         style_name
-                       end
+            style_id = resolve_style_id(style_name, style_map)
           end
 
           if style_id.nil?
             col_style = @column_styles ? @column_styles[col_index] : nil
-            col_style_id = if col_style && style_map
-                             style_map[col_style] || style_map[col_style.to_s] || col_style
-                           else
-                             col_style
-                           end
+            col_style_id = resolve_style_id(col_style, style_map)
             style_id = row_style_id || col_style_id
           end
 
@@ -638,7 +631,7 @@ module Xlsxrb
               end
             end
             f_attrs << ' ca="1"' if formula_ca
-            buf << "<f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
+            buf << "><f#{f_attrs}>" << escape_xml(formula_expr) << "</f>"
             if xml_val
               buf << "<v>" << xml_val.to_s << "</v></c>"
             else
@@ -662,12 +655,12 @@ module Xlsxrb
 
       # Write the worksheet footer. Call once after all rows.
       # Options for post-sheetData elements (in OOXML order):
-      def finish(drawing_rid: nil, sheet_protection: nil, auto_filter: nil,
+      def finish(drawing_rid: nil, sheet_protection: nil, protected_ranges: nil, auto_filter: nil,
                  filter_columns: nil, sort_state: nil, merge_cells: nil,
                  conditional_formats: nil, data_validations: nil,
                  hyperlinks: nil, print_options: nil, page_margins: nil,
                  page_setup: nil, header_footer: nil, row_breaks: nil,
-                 col_breaks: nil, tables: nil, table_start_rid: nil,
+                 col_breaks: nil, cell_watches: nil, tables: nil, table_start_rid: nil,
                  legacy_drawing_rid: nil, sparkline_groups: nil)
         return if @finished
 
@@ -681,6 +674,7 @@ module Xlsxrb
 
         # Elements must appear in OOXML specification order after sheetData
         write_sheet_protection(sheet_protection) if sheet_protection
+        write_protected_ranges(protected_ranges) if protected_ranges && !protected_ranges.empty?
         write_auto_filter(auto_filter, filter_columns, sort_state) if auto_filter
         write_merge_cells(merge_cells) if merge_cells && !merge_cells.empty?
         write_conditional_formatting(conditional_formats) if conditional_formats && !conditional_formats.empty?
@@ -692,6 +686,7 @@ module Xlsxrb
         write_header_footer(header_footer) if header_footer && !header_footer.empty?
         write_row_breaks(row_breaks) if row_breaks && !row_breaks.empty?
         write_col_breaks(col_breaks) if col_breaks && !col_breaks.empty?
+        write_cell_watches(cell_watches) if cell_watches && !cell_watches.empty?
         @builder.empty_tag("drawing", { "r:id": drawing_rid }) if drawing_rid
         @builder.empty_tag("legacyDrawing", { "r:id": legacy_drawing_rid }) if legacy_drawing_rid
         write_table_parts(tables, table_start_rid) if tables && !tables.empty?
@@ -701,6 +696,17 @@ module Xlsxrb
 
       private
 
+      def resolve_style_id(style, style_map)
+        return nil if style.nil?
+
+        if style_map
+          mapped = style_map[style] || style_map[style.to_s]
+          return mapped if mapped
+        end
+
+        style.is_a?(Integer) ? style : nil
+      end
+
       # --- Pre-sheetData elements ---
 
       def write_sheet_properties(props)
@@ -770,6 +776,22 @@ module Xlsxrb
         @builder.close_tag("sheetViews")
       end
 
+      def write_sheet_format_pr(fmt)
+        return if fmt.nil? || fmt.empty?
+
+        attrs = {}
+        attrs[:defaultRowHeight] = fmt[:default_row_height].to_s if fmt[:default_row_height]
+        attrs[:defaultColWidth] = fmt[:default_col_width].to_s if fmt[:default_col_width]
+        attrs[:baseColWidth] = fmt[:base_col_width].to_s if fmt[:base_col_width]
+        attrs[:outlineLevelRow] = fmt[:outline_level_row].to_s if fmt[:outline_level_row]
+        attrs[:outlineLevelCol] = fmt[:outline_level_col].to_s if fmt[:outline_level_col]
+        attrs[:customHeight] = "1" if fmt[:custom_height]
+        attrs[:zeroHeight] = "1" if fmt[:zero_height]
+        attrs[:thickTop] = "1" if fmt[:thick_top]
+        attrs[:thickBottom] = "1" if fmt[:thick_bottom]
+        @builder.empty_tag("sheetFormatPr", attrs) unless attrs.empty?
+      end
+
       # --- Post-sheetData elements (in OOXML order) ---
 
       def write_sheet_protection(opts)
@@ -798,6 +820,28 @@ module Xlsxrb
         @builder.empty_tag("sheetProtection", attrs)
       end
 
+      def write_protected_ranges(ranges)
+        @builder.open_tag("protectedRanges")
+        ranges.each do |pr|
+          attrs = { sqref: pr[:sqref].to_s, name: pr[:name].to_s }
+          attrs[:password] = pr[:password].to_s if pr[:password]
+          attrs[:algorithmName] = pr[:algorithm_name].to_s if pr[:algorithm_name]
+          attrs[:hashValue] = pr[:hash_value].to_s if pr[:hash_value]
+          attrs[:saltValue] = pr[:salt_value].to_s if pr[:salt_value]
+          attrs[:spinCount] = pr[:spin_count].to_s if pr[:spin_count]
+          attrs[:securityDescriptor] = pr[:security_descriptor].to_s if pr[:security_descriptor]
+          sds = pr[:security_descriptors] || []
+          if sds.empty?
+            @builder.empty_tag("protectedRange", attrs)
+          else
+            @builder.open_tag("protectedRange", attrs)
+            sds.each { |sd| @builder.tag("securityDescriptor") { @builder.text(sd.to_s) } }
+            @builder.close_tag("protectedRange")
+          end
+        end
+        @builder.close_tag("protectedRanges")
+      end
+
       def write_auto_filter(range, filter_columns, sort_state)
         if (filter_columns && !filter_columns.empty?) || sort_state
           @builder.open_tag("autoFilter", { ref: range })
@@ -1133,6 +1177,14 @@ module Xlsxrb
         @builder.close_tag("colBreaks")
       end
 
+      def write_cell_watches(watches)
+        @builder.open_tag("cellWatches")
+        watches.each do |w|
+          @builder.empty_tag("cellWatch", { r: w.to_s })
+        end
+        @builder.close_tag("cellWatches")
+      end
+
       def write_table_parts(tables, start_rid)
         @builder.open_tag("tableParts", { count: tables.size.to_s })
         tables.each_with_index do |_tbl, idx|
@@ -1243,7 +1295,7 @@ module Xlsxrb
         col_idx = cell[:column_index]
         col_style = @column_styles && col_idx ? @column_styles[col_idx] : nil
         style_id = cell[:style_index] || col_style
-        attrs[:s] = style_id.to_s if style_id
+        attrs[:s] = style_id.to_s if style_id.is_a?(Integer)
 
         if value.nil? && formula.nil?
           @builder.empty_tag("c", attrs)

data/lib/xlsxrb/ooxml/writer/features_xml.rb

@@ -715,7 +715,7 @@ module Xlsxrb
                        "<vt:i4>#{prop[:value]}</vt:i4>"
                      when :float, :r8
                        "<vt:r8>#{prop[:value]}</vt:r8>"
-                     when :bool
+                     when :bool, :boolean
                        "<vt:bool>#{prop[:value] ? "true" : "false"}</vt:bool>"
                      when :date, :filetime
                        "<vt:filetime>#{prop[:value]}</vt:filetime>"

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

@@ -397,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
 
@@ -437,7 +437,10 @@ 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?
+
+          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?("/")
@@ -496,7 +499,8 @@ 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
 
           norm_name = normalize_entry_name(entry_name)
@@ -645,6 +649,34 @@ module Xlsxrb
           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

data/lib/xlsxrb/stream_sheet.rb

@@ -314,7 +314,41 @@ module Xlsxrb
     # @api public
     #: () -> Elements::Worksheet
     def load
-      Xlsxrb.send(:build_worksheet, @name, raw_sheet_xml, @shared_strings, @styles, state: @state, zip_reader: @zip_reader, entry_name: @entry_name, hyperlinks: hyperlinks, comments: comments, images: images, date1904: @date1904, dimension: dimension, trim_empty_rows: @trim_empty_rows, pad_empty_rows: @pad_empty_rows, pad_empty_cells: @pad_empty_cells)
+      Xlsxrb.send(
+        :build_worksheet,
+        @name,
+        raw_sheet_xml,
+        @shared_strings,
+        @styles,
+        state: @state,
+        zip_reader: @zip_reader,
+        entry_name: @entry_name,
+        hyperlinks: hyperlinks,
+        comments: comments,
+        images: images,
+        date1904: @date1904,
+        dimension: dimension,
+        trim_empty_rows: @trim_empty_rows,
+        pad_empty_rows: @pad_empty_rows,
+        pad_empty_cells: @pad_empty_cells,
+        merged_cells: merged_cells,
+        auto_filter: auto_filter,
+        tables: tables,
+        shapes: shapes,
+        freeze_pane: freeze_pane,
+        page_setup: page_setup,
+        page_margins: page_margins,
+        header_footer: header_footer,
+        print_options: print_options,
+        sheet_protection: sheet_protection,
+        sheet_view: sheet_view,
+        sheet_properties: sheet_properties,
+        sheet_format: sheet_format,
+        row_breaks: row_breaks,
+        col_breaks: col_breaks,
+        protected_ranges: protected_ranges,
+        cell_watches: cell_watches
+      )
     end
     alias to_worksheet load
 
@@ -511,6 +545,169 @@ module Xlsxrb
       end
     end
 
+    # Returns tables defined in this worksheet.
+    #
+    # @return [Array<Hash[Symbol, untyped]>]
+    # @api public
+    #: () -> Array[Hash[Symbol, untyped]]
+    def tables
+      @tables ||= Xlsxrb.send(:resolve_tables, zip_reader: @zip_reader, entry_name: @entry_name)
+    end
+
+    # Returns shapes defined in this worksheet.
+    #
+    # @return [Array<Hash[Symbol, untyped]>]
+    # @api public
+    #: () -> Array[Hash[Symbol, untyped]]
+    def shapes
+      @shapes ||= Xlsxrb.send(:resolve_shapes, zip_reader: @zip_reader, entry_name: @entry_name)
+    end
+
+    # Returns freeze pane settings for this worksheet, or nil if none.
+    #
+    # @return [Hash[Symbol, untyped], nil]
+    # @api public
+    #: () -> Hash[Symbol, untyped]?
+    def freeze_pane
+      sheet_view_data[:pane]
+    end
+
+    # Returns sheet view properties for this worksheet.
+    #
+    # @return [Hash[Symbol, untyped]]
+    # @api public
+    #: () -> Hash[Symbol, untyped]
+    def sheet_view
+      sheet_view_data[:view] || {}
+    end
+
+    # Returns sheet protection settings as a hash, or nil if unprotected.
+    #
+    # @return [Hash[Symbol, untyped], nil]
+    # @api public
+    #: () -> Hash[Symbol, untyped]?
+    def sheet_protection
+      @sheet_protection ||= if raw_sheet_xml.include?("<sheetProtection")
+                              listener = Ooxml::Reader::SheetProtectionListener.new
+                              Ooxml::XmlParser.parse(raw_sheet_xml, listener)
+                              listener.protection
+                            end
+    end
+
+    # Returns sheet-level properties (tabColor, outlinePr) for this worksheet.
+    #
+    # @return [Hash[Symbol, untyped]]
+    # @api public
+    #: () -> Hash[Symbol, untyped]
+    def sheet_properties
+      @sheet_properties ||= if raw_sheet_xml.include?("<sheetPr")
+                              listener = Ooxml::Reader::SheetPropertiesListener.new
+                              Ooxml::XmlParser.parse(raw_sheet_xml, listener)
+                              listener.properties
+                            else
+                              {}
+                            end
+    end
+
+    # Returns sheet format properties (defaultRowHeight, defaultColWidth, baseColWidth) for this worksheet.
+    #
+    # @return [Hash[Symbol, untyped]]
+    # @api public
+    #: () -> Hash[Symbol, untyped]
+    def sheet_format
+      @sheet_format ||= if raw_sheet_xml.include?("<sheetFormatPr")
+                          listener = Ooxml::Reader::SheetFormatListener.new
+                          Ooxml::XmlParser.parse(raw_sheet_xml, listener)
+                          listener.properties
+                        else
+                          {}
+                        end
+    end
+
+    # Returns page setup configurations for this worksheet.
+    #
+    # @return [Hash[Symbol, untyped]]
+    # @api public
+    #: () -> Hash[Symbol, untyped]
+    def page_setup
+      print_page_data[:page_setup] || {}
+    end
+
+    # Returns page margins for this worksheet, or nil if none.
+    #
+    # @return [Hash[Symbol, untyped], nil]
+    # @api public
+    #: () -> Hash[Symbol, untyped]?
+    def page_margins
+      print_page_data[:page_margins]
+    end
+
+    # Returns header/footer configurations for this worksheet.
+    #
+    # @return [Hash[Symbol, untyped]]
+    # @api public
+    #: () -> Hash[Symbol, untyped]
+    def header_footer
+      print_page_data[:header_footer] || {}
+    end
+
+    # Returns print options for this worksheet.
+    #
+    # @return [Hash[Symbol, untyped]]
+    # @api public
+    #: () -> Hash[Symbol, untyped]
+    def print_options
+      print_page_data[:print_options] || {}
+    end
+
+    # Returns explicit row page breaks for this worksheet.
+    #
+    # @return [Array<untyped>]
+    # @api public
+    #: () -> Array[untyped]
+    def row_breaks
+      print_page_data[:row_breaks] || []
+    end
+
+    # Returns explicit column page breaks for this worksheet.
+    #
+    # @return [Array<untyped>]
+    # @api public
+    #: () -> Array[untyped]
+    def col_breaks
+      print_page_data[:col_breaks] || []
+    end
+
+    # Returns protected ranges defined for this worksheet.
+    #
+    # @return [Array<Hash[Symbol, untyped]>]
+    # @api public
+    #: () -> Array[Hash[Symbol, untyped]]
+    def protected_ranges
+      @protected_ranges ||= if raw_sheet_xml.include?("<protectedRanges")
+                              listener = Ooxml::Reader::ProtectedRangesListener.new
+                              Ooxml::XmlParser.parse(raw_sheet_xml, listener)
+                              listener.ranges
+                            else
+                              []
+                            end
+    end
+
+    # Returns cell watch cell references defined for this worksheet.
+    #
+    # @return [Array<String>]
+    # @api public
+    #: () -> Array[String]
+    def cell_watches
+      @cell_watches ||= if raw_sheet_xml.include?("<cellWatches")
+                          listener = Ooxml::Reader::CellWatchesListener.new
+                          Ooxml::XmlParser.parse(raw_sheet_xml, listener)
+                          listener.watches
+                        else
+                          []
+                        end
+    end
+
     # Closes any underlying reader resources.
     #: () -> void
     def close
@@ -520,7 +717,42 @@ module Xlsxrb
 
     private
 
-    # Returns the full raw XML string for this worksheet, loaded on demand.
+    #: () -> Hash[Symbol, untyped]
+    def sheet_view_data
+      @sheet_view_data ||= if raw_sheet_xml.include?("<sheetView")
+                             listener = Ooxml::Reader::SheetViewListener.new
+                             Ooxml::XmlParser.parse(raw_sheet_xml, listener)
+                             { view: listener.view, pane: listener.pane, selection: listener.selection }
+                           else
+                             { view: {}, pane: nil, selection: nil }
+                           end
+    end
+
+    #: () -> Hash[Symbol, untyped]
+    def print_page_data
+      @print_page_data ||= if raw_sheet_xml.match?(/<(?:pageSetup|pageMargins|headerFooter|printOptions|rowBreaks|colBreaks)\b/)
+                             listener = Ooxml::Reader::PrintPageListener.new
+                             Ooxml::XmlParser.parse(raw_sheet_xml, listener)
+                             {
+                               page_margins: listener.page_margins,
+                               page_setup: listener.page_setup,
+                               header_footer: listener.header_footer,
+                               print_options: listener.print_options,
+                               row_breaks: listener.row_breaks,
+                               col_breaks: listener.col_breaks
+                             }
+                           else
+                             {
+                               page_margins: nil,
+                               page_setup: {},
+                               header_footer: {},
+                               print_options: {},
+                               row_breaks: [],
+                               col_breaks: []
+                             }
+                           end
+    end
+
     #: () -> String
     def raw_sheet_xml
       @raw_sheet_xml ||= if @sheet_source.is_a?(String)