xlsxrb 0.1.0

data/lib/xlsxrb/ooxml/shared_strings_parser.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require_relative "xml_parser"
+
+module Xlsxrb
+  module Ooxml
+    # SAX-based parser for xl/sharedStrings.xml.
+    # Returns an Array of strings (index = SST index).
+    class SharedStringsParser
+      # Parses all shared strings and returns an Array of strings.
+      def self.parse(xml_string, part_name: "xl/sharedStrings.xml")
+        return [] if xml_string.nil? || xml_string.empty?
+
+        strings = []
+        each_event(xml_string, part_name: part_name) do |event|
+          strings << event.args[0] if event.type == :sst_item
+        end
+        strings
+      end
+
+      # Yields Event objects for each shared string.
+      def self.each_event(xml_string, part_name: "xl/sharedStrings.xml", &block)
+        return enum_for(:each_event, xml_string, part_name: part_name) unless block
+        return if xml_string.nil? || xml_string.empty?
+
+        listener = EventListener.new(part_name, &block)
+        XmlParser.parse(xml_string, listener)
+      end
+
+      # SAX listener for generating events from shared string table.
+      class EventListener
+        include REXML::SAX2Listener
+
+        def initialize(part_name, &block)
+          @part_name = part_name
+          @block = block
+          @in_si = false
+          @in_t = false
+          @current_text = +""
+          @index = 0
+        end
+
+        def start_element(_uri, localname, _qname, _attrs)
+          case localname
+          when "si"
+            @in_si = true
+            @current_text = +""
+          when "t"
+            @in_t = true
+          end
+        end
+
+        def end_element(_uri, localname, _qname)
+          case localname
+          when "si"
+            @in_si = false
+            frozen_str = @current_text.freeze
+            @block.call(Event.new(
+                          type: :sst_item,
+                          args: [frozen_str],
+                          source: { part: @part_name, index: @index }
+                        ))
+            @index += 1
+          when "t"
+            @in_t = false
+          end
+        end
+
+        def characters(text)
+          @current_text << text if @in_si && @in_t
+        end
+      end
+    end
+  end
+end

data/lib/xlsxrb/ooxml/styles_parser.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require_relative "xml_parser"
+
+module Xlsxrb
+  module Ooxml
+    # SAX-based parser for xl/styles.xml.
+    # Returns a Hash with :num_fmts, :fonts, :fills, :borders, :cell_xfs, :cell_style_xfs.
+    class StylesParser
+      def self.parse(xml_string)
+        return {} if xml_string.nil? || xml_string.empty?
+
+        listener = Listener.new
+        XmlParser.parse(xml_string, listener)
+        listener.result
+      end
+
+      # SAX listener for parsing styles.xml content.
+      class Listener
+        include REXML::SAX2Listener
+
+        attr_reader :result
+
+        def initialize
+          @result = {
+            num_fmts: {},
+            fonts: [],
+            fills: [],
+            borders: [],
+            cell_xfs: [],
+            cell_style_xfs: []
+          }
+          @context = []
+          @current_font = nil
+          @current_fill = nil
+          @current_fill_pattern = nil
+          @current_border = nil
+          @current_xf = nil
+          @in_cell_xfs = false
+          @in_cell_style_xfs = false
+        end
+
+        def start_element(_uri, localname, _qname, attrs)
+          @context.push(localname)
+          case localname
+          when "numFmt"
+            id = attrs["numFmtId"]&.to_i
+            code = attrs["formatCode"]
+            @result[:num_fmts][id] = code if id && code
+          when "font"
+            @current_font = {} if parent_context?("fonts")
+          when "b"
+            @current_font[:bold] = true if @current_font
+          when "i"
+            @current_font[:italic] = true if @current_font
+          when "u"
+            @current_font[:underline] = attrs["val"] || "single" if @current_font
+          when "sz"
+            @current_font[:sz] = attrs["val"]&.to_f if @current_font
+          when "color"
+            handle_color(attrs)
+          when "name"
+            @current_font[:name] = attrs["val"] if @current_font
+          when "fill"
+            @current_fill = {} if parent_context?("fills")
+          when "patternFill"
+            @current_fill_pattern = attrs["patternType"] if @current_fill
+          when "fgColor", "bgColor"
+            handle_fill_color(localname, attrs) if @current_fill
+          when "border"
+            @current_border = {} if parent_context?("borders")
+          when "left", "right", "top", "bottom", "diagonal"
+            handle_border_side(localname, attrs)
+          when "cellXfs"
+            @in_cell_xfs = true
+          when "cellStyleXfs"
+            @in_cell_style_xfs = true
+          when "xf"
+            handle_xf(attrs)
+          when "alignment"
+            handle_alignment(attrs)
+          end
+        end
+
+        def end_element(_uri, localname, _qname)
+          case localname
+          when "font"
+            if @current_font
+              @result[:fonts] << @current_font
+              @current_font = nil
+            end
+          when "fill"
+            if @current_fill
+              @current_fill[:pattern] = @current_fill_pattern if @current_fill_pattern
+              @result[:fills] << @current_fill
+              @current_fill = nil
+              @current_fill_pattern = nil
+            end
+          when "border"
+            if @current_border
+              @result[:borders] << @current_border
+              @current_border = nil
+            end
+          when "cellXfs"
+            @in_cell_xfs = false
+          when "cellStyleXfs"
+            @in_cell_style_xfs = false
+          when "xf"
+            finalize_xf
+          end
+          @context.pop
+        end
+
+        def characters(_text)
+          # No text content needed for styles
+        end
+
+        private
+
+        def parent_context?(tag)
+          @context.length >= 2 && @context[-2] == tag
+        end
+
+        def handle_color(attrs)
+          return unless @current_font
+
+          color = extract_color(attrs)
+          @current_font[:color] = color unless color.empty?
+        end
+
+        def handle_fill_color(localname, attrs)
+          color = extract_color(attrs)
+          return if color.empty?
+
+          key = localname == "fgColor" ? :fg_color : :bg_color
+          @current_fill[key] = color
+        end
+
+        def handle_border_side(side, attrs)
+          return unless @current_border
+
+          style = attrs["style"]
+          @current_border[side.to_sym] = { style: style } if style
+        end
+
+        def handle_xf(attrs)
+          @current_xf = {
+            num_fmt_id: attrs["numFmtId"]&.to_i,
+            font_id: attrs["fontId"]&.to_i,
+            fill_id: attrs["fillId"]&.to_i,
+            border_id: attrs["borderId"]&.to_i,
+            xf_id: attrs["xfId"]&.to_i,
+            apply_number_format: attrs["applyNumberFormat"] == "1",
+            apply_font: attrs["applyFont"] == "1",
+            apply_fill: attrs["applyFill"] == "1",
+            apply_border: attrs["applyBorder"] == "1",
+            apply_alignment: attrs["applyAlignment"] == "1"
+          }
+        end
+
+        def handle_alignment(attrs)
+          return unless @current_xf
+
+          alignment = {}
+          alignment[:horizontal] = attrs["horizontal"] if attrs["horizontal"]
+          alignment[:vertical] = attrs["vertical"] if attrs["vertical"]
+          alignment[:wrap_text] = true if attrs["wrapText"] == "1"
+          alignment[:text_rotation] = attrs["textRotation"]&.to_i if attrs["textRotation"]
+          @current_xf[:alignment] = alignment unless alignment.empty?
+        end
+
+        def finalize_xf
+          return unless @current_xf
+
+          if @in_cell_xfs
+            @result[:cell_xfs] << @current_xf
+          elsif @in_cell_style_xfs
+            @result[:cell_style_xfs] << @current_xf
+          end
+          @current_xf = nil
+        end
+
+        def extract_color(attrs)
+          color = {}
+          color[:rgb] = attrs["rgb"] if attrs["rgb"]
+          color[:theme] = attrs["theme"]&.to_i if attrs["theme"]
+          color[:indexed] = attrs["indexed"]&.to_i if attrs["indexed"]
+          color[:tint] = attrs["tint"]&.to_f if attrs["tint"]
+          color
+        end
+      end
+    end
+  end
+end

data/lib/xlsxrb/ooxml/utils.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "date"
+require "securerandom"
+require "openssl"
+
+module Xlsxrb
+  module Ooxml
+    # OOXML-specific utility methods and constants.
+    module Utils
+      # Excel 1900 date system epoch.
+      EPOCH_1900 = Date.new(1899, 12, 31) # serial 1 = Jan 1, 1900
+
+      # Built-in number format codes defined by SpreadsheetML.
+      BUILTIN_NUM_FMT_CODES = {
+        0 => "General",
+        1 => "0",
+        2 => "0.00",
+        3 => "#,##0",
+        4 => "#,##0.00",
+        9 => "0%",
+        10 => "0.00%",
+        11 => "0.00E+00",
+        12 => "# ?/?",
+        13 => "# ??/??",
+        14 => "mm-dd-yy",
+        15 => "d-mmm-yy",
+        16 => "d-mmm",
+        17 => "mmm-yy",
+        18 => "h:mm AM/PM",
+        19 => "h:mm:ss AM/PM",
+        20 => "h:mm",
+        21 => "h:mm:ss",
+        22 => "m/d/yy h:mm",
+        37 => "#,##0 ;(#,##0)",
+        38 => "#,##0 ;[Red](#,##0)",
+        39 => "#,##0.00;(#,##0.00)",
+        40 => "#,##0.00;[Red](#,##0.00)",
+        45 => "mm:ss",
+        46 => "[h]:mm:ss",
+        47 => "mmss.0",
+        48 => "##0.0E+0",
+        49 => "@"
+      }.freeze
+
+      # Built-in numFmtIds that represent date/time formats.
+      BUILTIN_DATE_FMT_IDS = [14, 15, 16, 17, 18, 19, 20, 21, 22].freeze
+
+      # Default date format code used by Writer for Date cells.
+      DEFAULT_DATE_FORMAT = "yyyy\\-mm\\-dd"
+
+      # Default date-time format code used by Writer for Time cells.
+      DEFAULT_DATETIME_FORMAT = "yyyy\\-mm\\-dd\\ hh:mm:ss"
+
+      class << self
+        # Converts a Date to an Excel serial number (1900 system).
+        def date_to_serial(date)
+          serial = (date - EPOCH_1900).to_i
+          # Lotus 1-2-3 bug: serial 60 = Feb 29, 1900 (doesn't exist).
+          # Dates on or after Mar 1, 1900 (raw serial >= 60) need +1.
+          serial += 1 if serial >= 60
+          serial
+        end
+
+        # Converts an Excel serial number (1900 system) to a Date.
+        def serial_to_date(serial)
+          # Adjust for Lotus 1-2-3 bug.
+          serial -= 1 if serial > 60
+          EPOCH_1900 + serial
+        end
+
+        # Converts a Time to a fractional Excel serial number (1900 system).
+        def datetime_to_serial(time)
+          date = time.to_date
+          day_serial = date_to_serial(date)
+          # Fractional part: seconds since midnight / seconds per day
+          seconds_since_midnight = (time.hour * 3600) + (time.min * 60) + time.sec
+          day_serial + (seconds_since_midnight.to_f / 86_400)
+        end
+
+        # Converts a fractional Excel serial number to a Time (1900 system, UTC).
+        def serial_to_datetime(serial)
+          int_part = serial.to_i
+          frac = serial - int_part
+          date = serial_to_date(int_part)
+          total_seconds = (frac * 86_400).round
+          hours = total_seconds / 3600
+          minutes = (total_seconds % 3600) / 60
+          seconds = total_seconds % 60
+          Time.utc(date.year, date.month, date.day, hours, minutes, seconds)
+        end
+
+        # Hashes a plain-text password for use with sheet/workbook protection.
+        # Returns { algorithm_name:, hash_value:, salt_value:, spin_count: }.
+        # Algorithm per ECMA-376 Part 4 §2.4.2.24.
+        def hash_password(password, algorithm: "SHA-512", salt: nil, spin_count: 100_000)
+          raise ArgumentError, "password must be a String" unless password.is_a?(String)
+          raise ArgumentError, "spin_count must be a positive Integer" unless spin_count.is_a?(Integer) && spin_count.positive?
+
+          salt_bytes = (salt || SecureRandom.random_bytes(16)).b
+          # OOXML sheet/workbook protection hashing uses UTF-16LE password bytes.
+          password_bytes = password.encode("UTF-16LE").b
+
+          digest_name = algorithm.tr("-", "")
+          hash = OpenSSL::Digest.digest(digest_name, salt_bytes + password_bytes)
+
+          spin_count.times do |i|
+            iteration_bytes = [i].pack("V") # little-endian uint32
+            hash = OpenSSL::Digest.digest(digest_name, hash + iteration_bytes)
+          end
+
+          {
+            algorithm_name: algorithm,
+            hash_value: [hash].pack("m0"),
+            salt_value: [salt_bytes].pack("m0"),
+            spin_count: spin_count
+          }
+        end
+      end
+    end
+  end
+end

data/lib/xlsxrb/ooxml/workbook_parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "xml_parser"
+
+module Xlsxrb
+  module Ooxml
+    # SAX-based parser for xl/workbook.xml.
+    # Returns sheet list: [{ name:, sheet_id:, r_id: }, ...].
+    class WorkbookParser
+      def self.parse(xml_string)
+        return [] if xml_string.nil? || xml_string.empty?
+
+        listener = Listener.new
+        XmlParser.parse(xml_string, listener)
+        listener.sheets
+      end
+
+      # SAX listener for workbook.xml sheets.
+      class Listener
+        include REXML::SAX2Listener
+
+        attr_reader :sheets
+
+        def initialize
+          @sheets = []
+        end
+
+        def start_element(_uri, localname, _qname, attrs)
+          return unless localname == "sheet"
+
+          @sheets << {
+            name: attrs["name"],
+            sheet_id: attrs["sheetId"]&.to_i,
+            r_id: attrs["r:id"] || attrs["id"] || attrs.find { |k, _| k.end_with?(":id") }&.last
+          }
+        end
+
+        def end_element(_uri, _localname, _qname); end
+
+        def characters(_text); end
+      end
+    end
+
+    # Parses .rels files to build rId -> target mapping.
+    class RelationshipsParser
+      def self.parse(xml_string)
+        return {} if xml_string.nil? || xml_string.empty?
+
+        listener = Listener.new
+        XmlParser.parse(xml_string, listener)
+        listener.relationships
+      end
+
+      # SAX listener for .rels relationship files.
+      class Listener
+        include REXML::SAX2Listener
+
+        attr_reader :relationships
+
+        def initialize
+          @relationships = {}
+        end
+
+        def start_element(_uri, localname, _qname, attrs)
+          return unless localname == "Relationship"
+
+          rid = attrs["Id"]
+          target = attrs["Target"]
+          @relationships[rid] = target if rid && target
+        end
+
+        def end_element(_uri, _localname, _qname); end
+
+        def characters(_text); end
+      end
+    end
+  end
+end