xlsxrb 0.1.0

data/lib/xlsxrb/ooxml/xml_builder.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module Xlsxrb
+  module Ooxml
+    # Streams well-formed XML to a writable IO without building a DOM.
+    class XmlBuilder
+      XML_HEADER = %(<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n)
+
+      ESCAPE_MAP = {
+        "&" => "&amp;",
+        "<" => "&lt;",
+        ">" => "&gt;",
+        '"' => "&quot;",
+        "'" => "&apos;"
+      }.freeze
+
+      ESCAPE_RE = /[&<>"']/
+
+      def initialize(io)
+        @io = io
+      end
+
+      def declaration
+        @io << XML_HEADER
+        self
+      end
+
+      # Opens a tag, yields for children, then closes the tag.
+      def tag(name, attrs = {}, &block)
+        if block
+          open_tag(name, attrs)
+          yield self
+          close_tag(name)
+        else
+          empty_tag(name, attrs)
+        end
+        self
+      end
+
+      def open_tag(name, attrs = {})
+        @io << "<#{name}"
+        write_attrs(attrs)
+        @io << ">"
+        self
+      end
+
+      def close_tag(name)
+        @io << "</#{name}>"
+        self
+      end
+
+      def empty_tag(name, attrs = {})
+        @io << "<#{name}"
+        write_attrs(attrs)
+        @io << "/>"
+        self
+      end
+
+      def text(content)
+        @io << escape(content.to_s)
+        self
+      end
+
+      # Write raw XML string (for unmapped_data restoration).
+      def raw(xml_string)
+        @io << xml_string
+        self
+      end
+
+      # Serialize an unmapped_data hash back to XML.
+      def write_unmapped(node)
+        return unless node.is_a?(Hash) && node[:tag]
+
+        tag_name = node[:tag]
+        attrs = node[:attrs] || {}
+        children = node[:children] || []
+        text_content = node[:text]
+
+        if children.empty? && (text_content.nil? || text_content.empty?)
+          empty_tag(tag_name, attrs)
+        else
+          open_tag(tag_name, attrs)
+          text(text_content) if text_content && !text_content.empty?
+          children.each { |child| write_unmapped(child) }
+          close_tag(tag_name)
+        end
+      end
+
+      def to_s
+        @io.is_a?(StringIO) ? @io.string : @io.to_s
+      end
+
+      private
+
+      def write_attrs(attrs)
+        attrs.each do |k, v|
+          next if v.nil?
+
+          @io.write(" ")
+          @io.write(k.to_s)
+          @io.write('="')
+          @io.write(escape(v))
+          @io.write('"')
+        end
+      end
+
+      def escape(value)
+        str = value.to_s
+        str.match?(ESCAPE_RE) ? str.gsub(ESCAPE_RE, ESCAPE_MAP) : str
+      end
+    end
+  end
+end

data/lib/xlsxrb/ooxml/xml_parser.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "rexml/parsers/sax2parser"
+require "rexml/sax2listener"
+
+module Xlsxrb
+  module Ooxml
+    # Thin wrapper around REXML SAX2 parser for streaming XML processing.
+    # Unknown elements are captured as unmapped data hashes.
+    module XmlParser
+      # Parses XML string using SAX2, calling the given listener.
+      def self.parse(xml_string, listener)
+        parser = REXML::Parsers::SAX2Parser.new(xml_string)
+        parser.listen(listener)
+        parser.parse
+      end
+
+      # Base listener with unmapped-data collection support.
+      class BaseListener
+        include REXML::SAX2Listener
+
+        attr_reader :unmapped_data
+
+        def initialize
+          @unmapped_data = []
+          @unmapped_stack = []
+          @capturing_unmapped = false
+          @current_unmapped = nil
+        end
+
+        # Override in subclass: return true if the tag is recognized.
+        def recognized_tag?(_uri, _localname, _qname)
+          false
+        end
+
+        def start_element(uri, localname, qname, attrs)
+          if @capturing_unmapped
+            child = { tag: localname, attrs: attrs.dup, children: [], text: nil }
+            @unmapped_stack.last[:children] << child
+            @unmapped_stack.push(child)
+          elsif !recognized_tag?(uri, localname, qname)
+            @capturing_unmapped = true
+            @current_unmapped = { tag: localname, attrs: attrs.dup, children: [], text: nil }
+            @unmapped_stack.push(@current_unmapped)
+          end
+        end
+
+        def end_element(_uri, _localname, _qname)
+          return unless @capturing_unmapped
+
+          @unmapped_stack.pop
+          return unless @unmapped_stack.empty?
+
+          @capturing_unmapped = false
+          @unmapped_data << @current_unmapped
+          @current_unmapped = nil
+        end
+
+        def characters(text)
+          return unless @capturing_unmapped && !@unmapped_stack.empty?
+
+          current = @unmapped_stack.last
+          current[:text] = (current[:text] || "") + text
+        end
+      end
+    end
+  end
+end

data/lib/xlsxrb/ooxml/zip_generator.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Xlsxrb
+  module Ooxml
+    # Generates a simple ZIP file using only the standard library.
+    class ZipGenerator
+      def initialize(filepath)
+        @filepath = filepath
+        @entries = []
+        @file = nil
+      end
+
+      # Adds an entry to the ZIP archive.
+      def add_entry(filepath, content)
+        compressed_data = compress(content)
+        @entries << {
+          path: filepath,
+          content: content,
+          compressed_data: compressed_data,
+          crc32: crc32(content),
+          uncompressed_size: content.bytesize,
+          compressed_size: compressed_data.bytesize,
+          mtime: Time.now
+        }
+      end
+
+      # Generates the ZIP file.
+      def generate
+        File.open(@filepath, "wb") do |f|
+          @file = f
+          write_entries
+          write_central_directory
+        end
+      end
+
+      private
+
+      def write_entries
+        @entries.each do |entry|
+          write_local_header(entry)
+          write_file_data(entry)
+        end
+      end
+
+      def write_local_header(entry)
+        filename = entry[:path]
+        filename_bytes = filename.bytes
+
+        # Local file header
+        local_header = []
+        local_header += [0x50, 0x4b, 0x03, 0x04] # Signature
+        local_header += [0x14, 0x00]  # Version needed to extract
+        local_header += [0x00, 0x00]  # General purpose bit flag
+        local_header += [0x08, 0x00]  # Compression method (8 = deflate)
+
+        # Last mod file time/date
+        dos_time = dos_datetime(entry[:mtime])
+        local_header += dos_time
+
+        local_header += le32(entry[:crc32]) # CRC-32
+        local_header += le32(entry[:compressed_size]) # Compressed size
+        local_header += le32(entry[:uncompressed_size]) # Uncompressed size
+        local_header += le16(filename_bytes.length) # Filename length
+        local_header += le16(0) # Extra field length
+
+        @file.write(local_header.pack("C*"))
+        @file.write(filename)
+      end
+
+      def write_file_data(entry)
+        @file.write(entry[:compressed_data])
+      end
+
+      def write_central_directory
+        offset = @file.pos
+        cd_offset = 0
+        @entries.each do |entry|
+          filename = entry[:path]
+          filename_bytes = filename.bytes
+
+          cd_header = []
+          cd_header += [0x50, 0x4b, 0x01, 0x02] # Central directory file header signature
+          cd_header += [0x14, 0x03]  # Version made by
+          cd_header += [0x14, 0x00]  # Version needed to extract
+          cd_header += [0x00, 0x00]  # General purpose bit flag
+          cd_header += [0x08, 0x00]  # Compression method
+
+          dos_time = dos_datetime(entry[:mtime])
+          cd_header += dos_time
+
+          cd_header += le32(entry[:crc32]) # CRC-32
+          cd_header += le32(entry[:compressed_size]) # Compressed size
+          cd_header += le32(entry[:uncompressed_size]) # Uncompressed size
+          cd_header += le16(filename_bytes.length) # Filename length
+          cd_header += le16(0)  # Extra field length
+          cd_header += le16(0)  # File comment length
+          cd_header += le16(0)  # Disk number start
+          cd_header += le16(0)  # Internal file attributes
+          cd_header += le32(0)  # External file attributes
+          cd_header += le32(cd_offset) # Local header offset
+
+          @file.write(cd_header.pack("C*"))
+          @file.write(filename)
+
+          # Advance offset past the local header and compressed data for this entry.
+          cd_offset += 30 + filename_bytes.length + entry[:compressed_size]
+        end
+
+        # End of central directory record
+        end_cd = []
+        end_cd += [0x50, 0x4b, 0x05, 0x06] # End of central directory signature
+        end_cd += le16(0)  # Disk number
+        end_cd += le16(0)  # Disk with central directory
+        end_cd += le16(@entries.length)  # Number of central directory records on this disk
+        end_cd += le16(@entries.length)  # Total number of central directory records
+        end_cd += le32(calculate_central_dir_size) # Size of central directory
+        end_cd += le32(offset) # Offset of central directory
+        end_cd += le16(0) # Comment length
+
+        @file.write(end_cd.pack("C*"))
+      end
+
+      def compress(content)
+        deflater = Zlib::Deflate.new(Zlib::DEFAULT_COMPRESSION, -Zlib::MAX_WBITS)
+        begin
+          deflater.deflate(content, Zlib::FINISH)
+        ensure
+          deflater.close
+        end
+      end
+
+      def crc32(content)
+        Zlib.crc32(content) & 0xFFFFFFFF
+      end
+
+      def dos_datetime(time)
+        dos_date = ((time.year - 1980) << 9) | (time.month << 5) | time.day
+        dos_time = (time.hour << 11) | (time.min << 5) | (time.sec / 2)
+        le16(dos_time) + le16(dos_date)
+      end
+
+      def le16(value)
+        [(value & 0xFF), ((value >> 8) & 0xFF)]
+      end
+
+      def le32(value)
+        [(value & 0xFF), ((value >> 8) & 0xFF), ((value >> 16) & 0xFF), ((value >> 24) & 0xFF)]
+      end
+
+      def calculate_central_dir_size
+        size = 0
+        @entries.each do |entry|
+          filename = entry[:path]
+          size += 46 + filename.bytesize
+        end
+        size
+      end
+    end
+  end
+end

data/lib/xlsxrb/ooxml/zip_reader.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require "zlib"
+require "stringio"
+
+module Xlsxrb
+  module Ooxml
+    # Reads ZIP archives using only stdlib (zlib).
+    # Scans local file headers sequentially — works with non-seekable IO.
+    class ZipReader
+      LOCAL_HEADER_SIG = [0x50, 0x4B, 0x03, 0x04].pack("C4")
+
+      # Opens a ZIP from a file path or IO and yields the reader.
+      def self.open(source)
+        io = source.is_a?(String) ? File.open(source, "rb") : source
+        reader = new(io)
+        if block_given?
+          begin
+            yield reader
+          ensure
+            io.close if source.is_a?(String)
+          end
+        else
+          reader
+        end
+      end
+
+      def initialize(io)
+        @io = io
+        @entries = nil
+      end
+
+      # Returns a Hash { entry_name => raw_bytes } for all entries.
+      def read_all
+        result = {}
+        each_entry { |name, data| result[name] = data }
+        result
+      end
+
+      # Returns raw bytes for a single entry, or nil if not found.
+      def read_entry(name)
+        entries[name]
+      end
+
+      # Yields (entry_name, data_string) for each file in the archive.
+      def each_entry(&block)
+        return enum_for(:each_entry) unless block
+
+        entries.each_pair(&block)
+      end
+
+      private
+
+      def entries
+        @entries ||= parse_entries
+      end
+
+      def parse_entries
+        result = {}
+        data = @io.is_a?(StringIO) ? @io.string : @io.read
+        data = data.b
+        pos = 0
+
+        while pos + 4 <= data.bytesize
+          sig = data[pos, 4]
+          break unless sig == LOCAL_HEADER_SIG
+
+          # Local file header: 4 sig + 2 version + 2 flags + 2 method + 2 time + 2 date
+          #   + 4 crc + 4 compressed + 4 uncompressed + 2 name_len + 2 extra_len = 30 bytes
+          break if pos + 30 > data.bytesize
+
+          gp_flag        = data[pos + 6, 2].unpack1("v")
+          method         = data[pos + 8, 2].unpack1("v")
+          data[pos + 14, 4].unpack1("V")
+          compressed_size = data[pos + 18, 4].unpack1("V")
+          data[pos + 22, 4].unpack1("V")
+          name_len       = data[pos + 26, 2].unpack1("v")
+          extra_len      = data[pos + 28, 2].unpack1("v")
+
+          entry_name = data[pos + 30, name_len].force_encoding("UTF-8")
+          file_data_offset = pos + 30 + name_len + extra_len
+
+          # Data descriptor present if bit 3 of gp_flag is set
+          has_data_descriptor = gp_flag.anybits?(0x08)
+
+          if has_data_descriptor && compressed_size.zero?
+            # Need to find the data descriptor to know sizes
+            raw, comp_sz, = find_data_descriptor(data, file_data_offset, method)
+            entry_data = decompress(raw, method)
+            result[entry_name] = entry_data unless entry_name.end_with?("/")
+            # Skip past data + descriptor (12 or 16 bytes)
+            desc_offset = file_data_offset + comp_sz
+            # Check for optional signature
+            pos = if desc_offset + 4 <= data.bytesize && data[desc_offset, 4] == [0x50, 0x4B, 0x07, 0x08].pack("C4")
+                    desc_offset + 16
+                  else
+                    desc_offset + 12
+                  end
+          else
+            raw = data[file_data_offset, compressed_size]
+            entry_data = decompress(raw, method)
+            result[entry_name] = entry_data unless entry_name.end_with?("/")
+            pos = file_data_offset + compressed_size
+          end
+        end
+
+        result
+      end
+
+      def find_data_descriptor(data, offset, method)
+        # For deflated data, we inflate to find the end
+        if method == 8
+          inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+          result = +""
+          consumed = 0
+          chunk_size = 4096
+          pos = offset
+          begin
+            while pos < data.bytesize
+              chunk = data[pos, [chunk_size, data.bytesize - pos].min]
+              break if chunk.nil? || chunk.empty?
+
+              result << inflater.inflate(chunk)
+              consumed += chunk.bytesize
+              pos += chunk.bytesize
+            end
+          rescue Zlib::BufError, Zlib::DataError
+            # Inflation ended — find actual consumed size
+          ensure
+            # Calculate actual compressed bytes consumed
+            consumed -= inflater.avail_in
+            inflater.close
+          end
+          [result, consumed, result.bytesize]
+        else
+          # Stored — scan for data descriptor signature or central directory
+          # This is a fallback; stored + data descriptor is rare
+          [data[offset, 0], 0, 0]
+        end
+      end
+
+      def decompress(raw, method)
+        return raw&.dup&.force_encoding("UTF-8") || "" if method.zero? # stored
+
+        # Deflated
+        Zlib::Inflate.inflate(-raw || "")
+      rescue Zlib::DataError
+        # Try with raw deflate (no header)
+        inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+        begin
+          inflater.inflate(raw || "")
+        ensure
+          inflater.close
+        end
+      end
+    end
+  end
+end

data/lib/xlsxrb/ooxml/zip_writer.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "zlib"
+
+module Xlsxrb
+  module Ooxml
+    # Writes ZIP archives using only stdlib (zlib).
+    # Supports streaming: entries are written sequentially, central directory at close.
+    class ZipWriter
+      def self.open(target, &block)
+        io = target.is_a?(String) ? File.open(target, "wb") : target
+        writer = new(io)
+        if block
+          begin
+            yield writer
+          ensure
+            writer.close
+            io.close if target.is_a?(String)
+          end
+        else
+          writer
+        end
+      end
+
+      def initialize(io)
+        @io = io
+        @entries = []
+        @closed = false
+      end
+
+      # Add a file entry with string content.
+      def add_entry(path, content)
+        raise "ZipWriter is closed" if @closed
+
+        content_bytes = content.encode("UTF-8").b
+        write_raw_entry(path, content_bytes)
+      end
+
+      # Add a file entry with binary content (no encoding conversion).
+      def add_binary_entry(path, content)
+        raise "ZipWriter is closed" if @closed
+
+        content_bytes = content.b
+        write_raw_entry(path, content_bytes)
+      end
+
+      # Write a string directly into the current ZIP entry stream.
+      # Use start_entry / write_data / finish_entry for true streaming.
+      def start_entry(path)
+        raise "ZipWriter is closed" if @closed
+
+        @current_entry = {
+          path: path,
+          offset: @io.is_a?(StringIO) ? @io.pos : @io.tell,
+          deflater: Zlib::Deflate.new(Zlib::DEFAULT_COMPRESSION, -Zlib::MAX_WBITS),
+          crc: Zlib.crc32,
+          uncompressed_size: 0,
+          compressed_size: 0
+        }
+
+        # Write a placeholder local header (will be patched later if IO supports seek)
+        write_local_header(path, 0, 0, 0)
+      end
+
+      def write_data(str)
+        raise "No entry started" unless @current_entry
+
+        bytes = str.b
+        return if bytes.empty?
+
+        @current_entry[:crc] = Zlib.crc32(bytes, @current_entry[:crc])
+        @current_entry[:uncompressed_size] += bytes.bytesize
+        compressed = @current_entry[:deflater].deflate(bytes, Zlib::SYNC_FLUSH)
+        @current_entry[:compressed_size] += compressed.bytesize
+        @io.write(compressed)
+      end
+
+      def finish_entry
+        raise "No entry started" unless @current_entry
+
+        entry = @current_entry
+        @current_entry = nil
+
+        # Flush remaining deflate data
+        remaining = entry[:deflater].finish
+        entry[:compressed_size] += remaining.bytesize
+        @io.write(remaining)
+        entry[:deflater].close
+
+        final_crc = entry[:crc] & 0xFFFFFFFF
+
+        # Patch the local header if seekable
+        current_pos = @io.is_a?(StringIO) ? @io.pos : @io.tell
+        if @io.respond_to?(:seek)
+          @io.seek(entry[:offset])
+          write_local_header(entry[:path], final_crc, entry[:compressed_size], entry[:uncompressed_size])
+          @io.seek(current_pos)
+        end
+
+        @entries << {
+          path: entry[:path],
+          crc32: final_crc,
+          compressed_size: entry[:compressed_size],
+          uncompressed_size: entry[:uncompressed_size],
+          offset: entry[:offset]
+        }
+      end
+
+      def close
+        return if @closed
+
+        finish_entry if @current_entry
+
+        @closed = true
+        cd_offset = @io.is_a?(StringIO) ? @io.pos : @io.tell
+        cd_size = write_central_directory
+        write_end_of_central_directory(cd_offset, cd_size)
+      end
+
+      private
+
+      def write_raw_entry(path, content_bytes)
+        crc = Zlib.crc32(content_bytes) & 0xFFFFFFFF
+        compressed = deflate(content_bytes)
+
+        offset = @io.is_a?(StringIO) ? @io.pos : @io.tell
+
+        write_local_header(path, crc, compressed.bytesize, content_bytes.bytesize)
+        @io.write(compressed)
+
+        @entries << {
+          path: path,
+          crc32: crc,
+          compressed_size: compressed.bytesize,
+          uncompressed_size: content_bytes.bytesize,
+          offset: offset
+        }
+      end
+
+      def deflate(content)
+        deflater = Zlib::Deflate.new(Zlib::DEFAULT_COMPRESSION, -Zlib::MAX_WBITS)
+        begin
+          deflater.deflate(content, Zlib::FINISH)
+        ensure
+          deflater.close
+        end
+      end
+
+      def write_local_header(path, crc, compressed_size, uncompressed_size)
+        name_bytes = path.encode("UTF-8").b
+        header = [
+          0x04034B50,        # local file header signature
+          20,                # version needed (2.0)
+          0,                 # general purpose bit flag
+          8,                 # compression method (deflate)
+          0,                 # last mod file time
+          33,                # last mod file date
+          crc,
+          compressed_size,
+          uncompressed_size,
+          name_bytes.bytesize,
+          0                  # extra field length
+        ].pack("VvvvvvVVVvv")
+        @io.write(header)
+        @io.write(name_bytes)
+      end
+
+      def write_central_directory
+        size = 0
+        @entries.each do |entry|
+          name_bytes = entry[:path].encode("UTF-8").b
+          header = [
+            0x02014B50,        # central directory file header signature
+            20,                # version made by
+            20,                # version needed
+            0,                 # general purpose bit flag
+            8,                 # compression method
+            0,                 # last mod file time
+            33,                # last mod file date
+            entry[:crc32],
+            entry[:compressed_size],
+            entry[:uncompressed_size],
+            name_bytes.bytesize,
+            0,                 # extra field length
+            0,                 # file comment length
+            0,                 # disk number start
+            0,                 # internal file attributes
+            0,                 # external file attributes
+            entry[:offset]     # relative offset of local header
+          ].pack("VvvvvvvVVVvvvvvVV")
+          @io.write(header)
+          @io.write(name_bytes)
+          size += header.bytesize + name_bytes.bytesize
+        end
+        size
+      end
+
+      def write_end_of_central_directory(cd_offset, cd_size)
+        eocd = [
+          0x06054B50,          # end of central dir signature
+          0,                   # disk number
+          0,                   # disk with central directory
+          @entries.size,       # entries on this disk
+          @entries.size,       # total entries
+          cd_size,             # size of central directory
+          cd_offset,           # offset of central directory
+          0                    # comment length
+        ].pack("VvvvvVVv")
+        @io.write(eocd)
+      end
+    end
+  end
+end