omnizip 0.3.8 → 0.3.10

data/lib/omnizip/formats/msi/table_parser.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    module Msi
+      # MSI Table Parser
+      #
+      # Parses MSI database tables from OLE streams. MSI uses a column-major
+      # storage format where each column's data is stored contiguously.
+      #
+      # Key tables for file extraction:
+      # - File: File entries with name, size, component, sequence
+      # - Component: Links files to directories
+      # - Directory: Directory hierarchy
+      # - Media: Cabinet file references
+      class TableParser
+        include Omnizip::Formats::Msi::Constants
+
+        # @return [StringPool] String pool for string lookups
+        attr_reader :string_pool
+
+        # @return [Hash] Parsed tables (table_name => rows)
+        attr_reader :tables
+
+        # @return [Hash] Column definitions (table_name => columns)
+        attr_reader :columns
+
+        # @return [Array<String>] Table names
+        attr_reader :table_names
+
+        # @return [Proc] Stream reader method
+        attr_reader :read_stream
+
+        # Initialize table parser
+        #
+        # @param string_pool [StringPool] String pool for lookups
+        # @param stream_reader [Proc] Method to read streams
+        def initialize(string_pool, stream_reader)
+          @string_pool = string_pool
+          @read_stream = stream_reader
+          @tables = {}
+          @columns = {}
+          @table_names = []
+          load_table_list
+          load_column_defs
+        end
+
+        # Get table rows
+        #
+        # @param table_name [String] Table name
+        # @return [Array<Hash>] Table rows (each row is a hash of column => value)
+        def table(table_name)
+          return @tables[table_name] if @tables.key?(table_name)
+
+          @tables[table_name] = parse_table(table_name)
+        end
+
+        # Get column definitions for table
+        #
+        # @param table_name [String] Table name
+        # @return [Array<Hash>] Column definitions
+        def column_defs(table_name)
+          @columns[table_name] || []
+        end
+
+        # Check if table exists
+        #
+        # @param table_name [String] Table name
+        # @return [Boolean]
+        def table_exists?(table_name)
+          @table_names.include?(table_name)
+        end
+
+        private
+
+        # Load list of table names from _Tables stream
+        def load_table_list
+          data = @read_stream.call(TABLES_STREAM)
+          return if data.nil? || data.empty?
+
+          # _Tables format: column-major with one column (Table string index)
+          # First 2 bytes appear to be header (skip)
+          # Then 2-byte string indices for each table name
+          return if data.bytesize < 4
+
+          # Skip first 2 bytes (header), read string indices
+          offset = 2
+          while offset + 2 <= data.bytesize
+            str_idx = data[offset, 2].unpack1("v")
+            name = @string_pool[str_idx]
+            @table_names << name if name
+            offset += 2
+          end
+        end
+
+        # Load column definitions from _Columns stream
+        def load_column_defs
+          data = @read_stream.call(COLUMNS_STREAM)
+          return if data.nil? || data.empty?
+
+          # _Columns format: column-major with 4 columns
+          # Column 1: Table (string index, 2 bytes)
+          # Column 2: Number (signed short, 2 bytes)
+          # Column 3: Name (string index, 2 bytes)
+          # Column 4: Type (unsigned short, 2 bytes)
+
+          # Determine number of rows
+          num_rows = data.bytesize / 8 # 4 columns * 2 bytes each
+
+          # Extract each column (column-major order)
+          col_size = num_rows * 2
+
+          table_col = data[0, col_size].unpack("v*")
+          number_col = data[col_size, col_size].unpack("v*")
+          name_col = data[col_size * 2, col_size].unpack("v*")
+          type_col = data[col_size * 3, col_size].unpack("v*")
+
+          # Build column definitions per table
+          num_rows.times do |i|
+            table_name = @string_pool[table_col[i]]
+            next unless table_name
+
+            col_name = @string_pool[name_col[i]]
+            next unless col_name
+
+            # Number column: signed short with nullable bit
+            raw_num = number_col[i]
+            col_num = raw_num & 0x7FFF
+            is_primary_key = raw_num.anybits?(0x8000)
+
+            # Type column: determine storage width
+            type_val = type_col[i]
+            col_type = parse_column_type(type_val)
+
+            @columns[table_name] ||= []
+            @columns[table_name] << {
+              name: col_name,
+              number: col_num,
+              type: col_type[:type],
+              width: col_type[:width],
+              nullable: col_type[:nullable],
+              primary_key: is_primary_key,
+            }
+          end
+
+          # Sort columns by number for each table
+          @columns.each_value do |cols|
+            cols.sort_by! { |c| c[:number] }
+          end
+        end
+
+        # Parse column type from raw type value
+        #
+        # Type encoding:
+        # - Low byte: length or type code
+        # - High byte: type category with nullable bit
+        #
+        # @param raw [Integer] Raw type value
+        # @return [Hash] Parsed type info
+        def parse_column_type(raw)
+          low_byte = raw & 0xFF
+          high_byte = (raw >> 8) & 0xFF
+          nullable = high_byte.anybits?(0x80)
+          type_id = high_byte & 0x7F
+
+          # Determine type and width based on type_id
+          # Type 1 = int, Type >= 0x10 = string
+          if type_id == 1
+            # Integer type
+            if low_byte == 2
+              { type: :i2, width: 2, nullable: nullable }
+            else
+              { type: :i4, width: 4, nullable: nullable }
+            end
+          elsif type_id == 2
+            # Long integer
+            { type: :i4, width: 4, nullable: nullable }
+          elsif type_id >= 0x10
+            # String type - width is always 2 (string pool index)
+            { type: :string, width: 2, nullable: nullable }
+          else
+            # Default to string
+            { type: :string, width: 2, nullable: nullable }
+          end
+        end
+
+        # Parse a table stream into rows
+        #
+        # @param table_name [String] Table name
+        # @return [Array<Hash>] Parsed rows
+        def parse_table(table_name)
+          rows = []
+          data = @read_stream.call(table_name)
+          return rows if data.nil? || data.empty?
+
+          column_defs = @columns[table_name]
+          return rows if column_defs.nil? || column_defs.empty?
+
+          # Calculate row count from data size and column widths
+          total_width = column_defs.sum { |c| c[:width] }
+          return rows if total_width.zero?
+
+          num_rows = data.bytesize / total_width
+
+          # Parse column by column (column-major order)
+          offset = 0
+          rows = Array.new(num_rows) { {} }
+
+          column_defs.each do |col|
+            num_rows.times do |row_idx|
+              value = read_column_value(data, offset, col)
+              rows[row_idx][col[:name]] = value
+              offset += col[:width]
+            end
+          end
+
+          rows
+        end
+
+        # Read a single column value from data
+        #
+        # @param data [String] Raw table data
+        # @param offset [Integer] Current offset
+        # @param col [Hash] Column definition
+        # @return [Object] Parsed value
+        def read_column_value(data, offset, col)
+          case col[:type]
+          when :string
+            str_idx = data[offset, 2]&.unpack1("v") || 0
+            @string_pool[str_idx]
+          when :i2
+            val = data[offset, 2]&.unpack1("v") || 0
+            # Handle nullable marker
+            col[:nullable] ? (val & 0x7FFF) : val
+          when :i4
+            val = data[offset, 4]&.unpack1("V") || 0
+            # Handle nullable marker (high bit)
+            col[:nullable] ? (val & 0x7FFFFFFF) : val
+          end
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/formats/msi.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Formats
+    # MSI (Microsoft Installer) format support
+    #
+    # Provides read access to MSI packages, extracting files from
+    # embedded or external cabinet archives.
+    #
+    # MSI files are OLE compound documents containing:
+    # - Database tables (File, Component, Directory, Media, etc.)
+    # - String pool for interned strings
+    # - Embedded cabinets (in _Streams or direct OLE streams)
+    module Msi
+      autoload :Constants, "omnizip/formats/msi/constants"
+      autoload :Entry, "omnizip/formats/msi/entry"
+      autoload :StringPool, "omnizip/formats/msi/string_pool"
+      autoload :TableParser, "omnizip/formats/msi/table_parser"
+      autoload :DirectoryResolver, "omnizip/formats/msi/directory_resolver"
+      autoload :CabExtractor, "omnizip/formats/msi/cab_extractor"
+      autoload :Reader, "omnizip/formats/msi/reader"
+
+      class << self
+        # Open MSI file and return reader
+        #
+        # @param path [String] Path to MSI file
+        # @yield [Reader] Reader instance
+        # @return [Reader]
+        def open(path)
+          reader = Reader.new(path)
+          reader.open
+          if block_given?
+            begin
+              yield reader
+            ensure
+              reader.close
+            end
+          else
+            reader
+          end
+        end
+
+        # List files in MSI package
+        #
+        # @param path [String] Path to MSI file
+        # @return [Array<String>] File paths
+        def list(path)
+          open(path) { |r| r.files.map(&:path) }
+        end
+
+        # Extract all files from MSI package
+        #
+        # @param path [String] Path to MSI file
+        # @param output_dir [String] Output directory
+        # @return [Array<String>] Extracted file paths
+        def extract(path, output_dir)
+          open(path) do |reader|
+            reader.extract(output_dir)
+            reader.files.map { |f| File.join(output_dir, f.path) }
+          end
+        end
+
+        # Get information about MSI package
+        #
+        # @param path [String] Path to MSI file
+        # @return [Hash] Package information
+        def info(path)
+          open(path, &:info)
+        end
+
+        # Register MSI format with format registry
+        #
+        # This overrides OLE's .msi registration.
+        def register!
+          FormatRegistry.register(".msi", self)
+          FormatRegistry.register(".msp", self)
+        end
+      end
+    end
+  end
+end
+
+# Auto-register MSI format (overrides OLE's .msi registration)
+Omnizip::Formats::Msi.register!

data/lib/omnizip/formats/ole/allocation_table.rb

@@ -2,7 +2,6 @@
 
 require "set"
 
-require "omnizip/formats/ole"
 module Omnizip
   module Formats
     module Ole
@@ -63,6 +62,16 @@ module Omnizip
           @entries.length
         end
 
+        # Free resources to prevent memory leaks
+        #
+        # Call this when done with the allocation table to release memory.
+        # @return [void]
+        def free
+          @entries = nil
+          @ole = nil
+          @io = nil
+        end
+
         # Follow chain from starting index
         #
         # @param idx [Integer] Starting block index

data/lib/omnizip/formats/ole/dirent.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/formats/ole"
 module Omnizip
   module Formats
     module Ole
@@ -74,6 +73,12 @@ module Omnizip
         # @return [Array<Dirent>] Child entries (for directories)
         attr_reader :parent
 
+        # Public read access to the per-dirent name lookup hash. Used by
+        # children to update the parent's index when their name changes.
+        def name_lookup
+          @name_lookup ||= {}
+        end
+
         # @return [Integer, nil] Index in dirent array (used during loading)
         attr_accessor :idx
 
@@ -154,7 +159,7 @@ module Omnizip
         # @param value [String] Entry name
         def name=(value)
           if @parent
-            map = @parent.instance_variable_get(:@name_lookup)
+            map = @parent.name_lookup
             map&.delete(@name)
             map&.store(value, self)
           end
@@ -314,7 +319,7 @@ module Omnizip
           raise Errno::EISDIR unless file?
 
           io = RangesIOMigrateable.new(self, mode)
-          @modify_time = Time.now if io.respond_to?(:writeable?) && io.writeable?
+          @modify_time = Time.now if io.is_a?(RangesIOMigrateable) && io.writeable?
 
           if block_given?
             begin
@@ -366,6 +371,18 @@ module Omnizip
           @children&.each(&block)
         end
 
+        # Free resources to prevent memory leaks
+        #
+        # Call this when done with the dirent to release memory.
+        # @return [void]
+        def free
+          @children&.each { |child| child.free if child.is_a?(Dirent) }
+          @children = nil
+          @parent = nil
+          @ole = nil
+          @data = nil
+        end
+
         # Flatten tree to array for serialization
         #
         # @param dirents [Array<Dirent>] Output array

data/lib/omnizip/formats/ole/header.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/formats/ole"
 module Omnizip
   module Formats
     module Ole

data/lib/omnizip/formats/ole/ranges_io.rb

@@ -73,6 +73,15 @@ module Omnizip
           @pos = 0
         end
 
+        # Free resources to prevent memory leaks
+        #
+        # @return [void]
+        def free
+          @io = nil
+          @ranges = nil
+          @offsets = nil
+        end
+
         # Set position
         #
         # @param new_pos [Integer]
@@ -170,7 +179,7 @@ module Omnizip
         # @param data [String] Data to write
         # @return [Integer] Bytes written
         def write(data)
-          data = data.dup.force_encoding(Encoding::ASCII_8BIT) if data.respond_to?(:encoding)
+          data = data.dup.force_encoding(Encoding::ASCII_8BIT) if data.is_a?(String)
           return 0 if data.empty?
 
           # Grow if needed
@@ -217,9 +226,9 @@ module Omnizip
           raise NotImplementedError, "truncate not supported"
         end
 
-        # Close (no-op by default)
+        # Close and free resources
         def close
-          # No-op
+          free
         end
 
         # Inspect
@@ -262,6 +271,15 @@ module Omnizip
           max_pos = @ranges.map { |pos, len| pos + len }.max || 0
           @io.truncate(max_pos) if max_pos > @io.size
         end
+
+        # Free resources to prevent memory leaks
+        #
+        # @return [void]
+        def free
+          @bat = nil
+          @blocks = nil
+          super
+        end
       end
 
       # RangesIO that can migrate between BAT and SBAT based on size

data/lib/omnizip/formats/ole/storage.rb

@@ -2,7 +2,6 @@
 
 require "set"
 
-require "omnizip/formats/ole"
 module Omnizip
   module Formats
     module Ole
@@ -80,7 +79,7 @@ module Omnizip
                                end
 
           # Force binary encoding
-          @io.set_encoding(Encoding::ASCII_8BIT) if @io.respond_to?(:set_encoding)
+          @io.set_encoding(Encoding::ASCII_8BIT) if @io.is_a?(::IO)
 
           # Determine if writable
           @writeable = determine_writeable(mode)
@@ -175,11 +174,27 @@ module Omnizip
 
         # Close storage
         def close
-          @sb_file&.close
           flush if @writeable
+          free
           @io.close if @close_parent
         end
 
+        # Free internal resources to prevent memory leaks
+        #
+        # Call this to release memory while keeping the IO open.
+        # @return [void]
+        def free
+          @sb_file&.free
+          @sb_file = nil
+          @sbat&.free
+          @sbat = nil
+          @bbat&.free
+          @bbat = nil
+          @dirents = nil
+          @root = nil
+          @header = nil
+        end
+
         # Flush all changes to disk
         #
         # Writes all metadata (dirents, allocation tables, header) to the file.
@@ -442,7 +457,7 @@ module Omnizip
           else
             begin
               @io.flush
-              @io.write_nonblock("") if @io.respond_to?(:write_nonblock)
+              @io.write_nonblock("") if @io.is_a?(::IO)
               true
             rescue IOError, Errno::EBADF
               false

data/lib/omnizip/formats/ole.rb

@@ -119,12 +119,10 @@ module Omnizip
 
         # Register OLE format in registry
         def register!
-          require "omnizip/format_registry"
           FormatRegistry.register(".ole", Storage)
           FormatRegistry.register(".doc", Storage)
           FormatRegistry.register(".xls", Storage)
           FormatRegistry.register(".ppt", Storage)
-          FormatRegistry.register(".msi", Storage)
         end
 
         private

data/lib/omnizip/formats/rar/block_parser.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/formats/rar"
 module Omnizip
   module Formats
     module Rar

data/lib/omnizip/formats/rar/compression/ppmd/encoder.rb

@@ -52,7 +52,7 @@ module Omnizip
 
             # Accessor for memory size (for testing)
             def memory_size
-              @model.instance_variable_get(:@mem_size)
+              @model.mem_size
             end
 
             # Initialize the RAR PPMd encoder

data/lib/omnizip/formats/rar/decompressor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "English"
+require "tmpdir"
 module Omnizip
   module Formats
     module Rar
@@ -114,12 +115,48 @@ module Omnizip
           #
           # @return [String, nil] Command path or nil
           def find_command
+            if Gem.win_platform?
+              find_command_windows
+            else
+              find_command_unix
+            end
+          end
+
+          # Find unrar command on Unix
+          #
+          # @return [String, nil] Command path or nil
+          def find_command_unix
             ["unrar", "/usr/bin/unrar", "/usr/local/bin/unrar"].each do |cmd|
-              return cmd if system("which #{cmd} > /dev/null 2>&1")
+              return cmd if system("which #{cmd} > #{File::NULL} 2>&1")
             end
             nil
           end
 
+          # Find unrar command on Windows
+          #
+          # @return [String, nil] Command path or nil
+          def find_command_windows
+            # Check for unrar in PATH
+            ["UnRAR.exe", "unrar.exe"].each do |cmd|
+              return cmd if system("where #{cmd} > #{File::NULL} 2>&1")
+            end
+
+            # Check common WinRAR install locations
+            [
+              File.join(ENV.fetch("ProgramFiles", 'C:\Program Files'),
+                        "WinRAR", "UnRAR.exe"),
+              File.join(
+                ENV.fetch("ProgramFiles(x86)",
+                          'C:\Program Files (x86)'),
+                "WinRAR", "UnRAR.exe"
+              ),
+            ].each do |path|
+              return "\"#{path}\"" if File.exist?(path)
+            end
+
+            nil
+          end
+
           # Get gem version
           #
           # @return [String] Version string

data/lib/omnizip/formats/rar/header.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/formats/rar"
 module Omnizip
   module Formats
     module Rar

data/lib/omnizip/formats/rar/rar5/writer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/parity/par2_creator"
-
 module Omnizip
   module Formats
     module Rar

data/lib/omnizip/formats/rar/reader.rb

@@ -2,7 +2,6 @@
 
 require "fileutils"
 
-require "omnizip/formats/rar"
 module Omnizip
   module Formats
     module Rar
@@ -243,7 +242,7 @@ module Omnizip
           return false unless @header.version == 4
 
           # Check if we have the compression method
-          return false unless entry.respond_to?(:method) && entry.method
+          return false if entry.nil? || entry.method.nil?
 
           # All RAR4 methods are supported by our Dispatcher
           true
@@ -261,7 +260,7 @@ module Omnizip
           File.open(output_path, "wb") do |output|
             # For now, assume METHOD_STORE (0x30)
             # Real implementation would get method from entry
-            method = entry.respond_to?(:method) ? entry.method : 0x30
+            method = entry.method || 0x30
 
             Compression::Dispatcher.decompress(method, compressed_data, output)
           end

data/lib/omnizip/formats/rar/writer.rb

@@ -4,7 +4,6 @@ require "fileutils"
 require "zlib"
 require "stringio"
 
-require "omnizip/formats/rar"
 module Omnizip
   module Formats
     module Rar

data/lib/omnizip/formats/rar.rb

@@ -164,8 +164,7 @@ module Omnizip
 
         # Auto-register .rar format
         def register!
-          require "omnizip/format_registry"
-          FormatRegistry.register(".rar", Reader)
+          FormatRegistry.register(".rar", "Omnizip::Formats::Rar::Reader")
         end
       end
     end
@@ -173,4 +172,5 @@ module Omnizip
 end
 
 # Auto-register when file is loaded
+# Note: Registration happens after all classes are loaded to avoid circular dependency
 Omnizip::Formats::Rar.register!

data/lib/omnizip/formats/rpm/entry.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/formats/rpm"
 module Omnizip
   module Formats
     module Rpm