omnizip 0.3.9 → 0.3.10

data/lib/omnizip/filter_registry.rb

@@ -1,133 +1,109 @@
 # frozen_string_literal: true
 
-#
-# Copyright (C) 2024 Ribose Inc.
-#
-# This file is part of Omnizip.
-#
-# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
-# Based on the 7-Zip LZMA SDK by Igor Pavlov.
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# See the COPYING file for the complete text of the license.
-#
-
 module Omnizip
-  # Registry for managing filter classes.
-  #
-  # This class provides a centralized registry for preprocessing filters,
-  # allowing filters to self-register and be retrieved by name.
-  # It implements a plugin-style architecture for extensibility.
-  class FilterRegistry
-    @filters = {}
+  class FilterRegistry < Omnizip::Registry
+    DEFAULT_FORMATS = %i[xz seven_zip].freeze
+
+    BUILTIN_FILTERS = {
+      "bcj-x86": "Omnizip::Filters::BcjX86",
+      "bcj-arm": "Omnizip::Filters::BcjArm",
+      "bcj-arm64": "Omnizip::Filters::BcjArm64",
+      "bcj-ia64": "Omnizip::Filters::BcjIa64",
+      "bcj-ppc": "Omnizip::Filters::BcjPpc",
+      "bcj-sparc": "Omnizip::Filters::BcjSparc",
+      bcj: "Omnizip::Filters::BCJ",
+      bcj2: "Omnizip::Filters::Bcj2",
+      delta: "Omnizip::Filters::Delta",
+    }.freeze
 
     class << self
-      # Register a filter class with format support.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @param filter_class [Class] The filter class to register
-      # @param formats [Array<Symbol>] Supported formats (default: [:xz,
-      #   :seven_zip])
-      # @return [void]
-      def register(name, filter_class, formats: %i[xz seven_zip])
+      def not_found_error_class
+        Omnizip::UnknownFilterError
+      end
+
+      def label
+        "Filter"
+      end
+
+      def register(name, filter_class, formats: DEFAULT_FORMATS)
         raise ArgumentError, "Filter name cannot be nil" if name.nil?
         raise ArgumentError, "Filter class cannot be nil" if filter_class.nil?
 
-        @filters[name.to_sym] = {
-          class: filter_class,
-          formats: formats,
-        }
+        synchronize do
+          storage[normalize_key(name)] = {
+            class: filter_class,
+            formats: formats,
+          }
+        end
+        filter_class
       end
       alias register_with_formats register
 
-      # Retrieve a filter class by name.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @raise [UnknownFilterError] If filter is not registered
-      # @return [Class] The registered filter class
       def get(name)
-        filter = @filters[name.to_sym]
-        unless filter
-          raise UnknownFilterError,
-                "Unknown filter: #{name}. " \
+        entry = entry_for(name)
+        unless entry
+          raise not_found_error_class,
+                "#{label} not registered: #{name.inspect}. " \
                 "Available: #{available.join(', ')}"
         end
 
-        filter[:class]
+        entry[:class]
       end
 
-      # Check if a filter is registered.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @return [Boolean] True if filter is registered, false otherwise
-      def registered?(name)
-        @filters.key?(name.to_sym)
-      end
-
-      # Get list of all registered filter names.
-      #
-      # @return [Array<Symbol>] Array of registered filter names
-      def available
-        @filters.keys
-      end
-
-      # Reset the registry (primarily for testing).
-      #
-      # @return [void]
-      def reset!
-        @filters.clear
-      end
-
-      # Get filter instance for specific format.
-      #
-      # Returns a new filter instance after verifying the filter supports
-      # the specified format.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @param format [Symbol] Format identifier (:xz, :seven_zip)
-      # @raise [KeyError] If filter is not registered
-      # @raise [ArgumentError] If filter doesn't support the format
-      # @return [Object] New filter instance
       def get_for_format(name, format)
-        filter_info = @filters[name.to_sym]
-        raise KeyError, "Filter not found: #{name}" unless filter_info
+        entry = entry_for(name)
+        raise KeyError, "Filter not found: #{name}" unless entry
 
-        unless filter_info[:formats].include?(format)
+        unless entry[:formats].include?(format)
           raise ArgumentError,
                 "Filter #{name} not supported for format #{format}"
         end
 
-        filter_info[:class].new
+        entry[:class].new
       end
 
-      # Check if filter supports specific format.
-      #
-      # @param name [Symbol, String] The name identifier for the filter
-      # @param format [Symbol] Format identifier
-      # @return [Boolean] True if filter supports the format
       def supports_format?(name, format)
-        return false unless @filters[name.to_sym]
+        entry = entry_for(name)
+        return false unless entry
 
-        filter_info = @filters[name.to_sym]
-        filter_info[:formats]&.include?(format)
+        entry[:formats]&.include?(format)
       end
 
-      # Get all filters supporting a specific format.
-      #
-      # @param format [Symbol] Format identifier
-      # @return [Array<Symbol>] Filter names supporting the format
       def filters_for_format(format)
-        @filters.select do |_, info|
-          info[:formats]&.include?(format)
-        end.keys
+        # Ensure all lazy triggers have fired so the format filter list
+        # reflects every registered builtin.
+        lazy_triggers.keys.dup.each { |name| get(name) }
+
+        storage.select { |_, info| info[:formats]&.include?(format) }.keys
+      end
+
+      private
+
+      def entry_for(name)
+        normalized = normalize_key(name)
+        entry = storage[normalized]
+        return entry if entry
+
+        trigger = lazy_triggers[normalized]
+        if trigger
+          synchronize { lazy_triggers.delete(normalized) }
+          trigger.call
+          entry = storage[normalized]
+          return entry if entry
+        end
+
+        nil
       end
     end
   end
+end
 
-  # Error raised when an unknown filter is requested
-  class UnknownFilterError < StandardError; end
+# Lazy triggers — calling the Filters::Registry.register_all re-runs
+# the registration of every builtin filter. Idempotent: register just
+# overwrites the storage entry. Survives reset! because the trigger
+# proc is held by FilterRegistry, not the storage.
+Omnizip::FilterRegistry::BUILTIN_FILTERS.each_key do |name|
+  Omnizip::FilterRegistry.register_lazy(name) do
+    Omnizip::Filters::Registry.register_all
+  end
 end

data/lib/omnizip/filters/bcj2.rb

@@ -16,8 +16,6 @@
 # See the COPYING file for the complete text of the license.
 #
 
-require "omnizip/filters"
-
 module Omnizip
   module Filters
     # BCJ2 filter for x86/x64 executables (4-stream variant).

data/lib/omnizip/filters/bcj_x86.rb

@@ -16,8 +16,6 @@
 # See the COPYING file for the complete text of the license.
 #
 
-require "omnizip/filters"
-
 module Omnizip
   module Filters
     # BCJ (Branch/Call/Jump) filter for x86/x64 executables.

data/lib/omnizip/filters/filter_base.rb

@@ -1,72 +1,6 @@
 # frozen_string_literal: true
 
-#
-# Copyright (C) 2024 Ribose Inc.
-#
-# This file is part of Omnizip.
-#
-# Omnizip is a pure Ruby port of 7-Zip compression algorithms.
-# Based on the 7-Zip LZMA SDK by Igor Pavlov.
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# See the COPYING file for the complete text of the license.
-#
-
-module Omnizip
-  module Filters
-    # Abstract base class for preprocessing filters.
-    #
-    # Filters are reversible transformations applied to data before
-    # compression to improve compression ratios. They are particularly
-    # effective for executable files and other structured data.
-    #
-    # All filter implementations should inherit from this class and
-    # implement the required methods.
-    class FilterBase
-      # Encode (preprocess) data for compression.
-      #
-      # This method transforms data to make it more compressible. The
-      # transformation must be reversible - decode(encode(data)) == data.
-      #
-      # @param data [String] Binary data to encode
-      # @param position [Integer] Current position in stream (for
-      #   multi-block filtering)
-      # @raise [NotImplementedError] Must be implemented by subclass
-      # @return [String] Encoded binary data
-      def encode(data, position = 0)
-        raise NotImplementedError,
-              "#{self.class} must implement #encode"
-      end
-
-      # Decode (postprocess) data after decompression.
-      #
-      # This method reverses the encoding transformation, restoring
-      # original data.
-      #
-      # @param data [String] Binary data to decode
-      # @param position [Integer] Current position in stream (for
-      #   multi-block filtering)
-      # @raise [NotImplementedError] Must be implemented by subclass
-      # @return [String] Decoded binary data
-      def decode(data, position = 0)
-        raise NotImplementedError,
-              "#{self.class} must implement #decode"
-      end
-
-      class << self
-        # Get metadata about this filter.
-        #
-        # @raise [NotImplementedError] Must be implemented by subclass
-        # @return [Hash] Filter metadata including name, description
-        def metadata
-          raise NotImplementedError,
-                "#{self} must implement .metadata"
-        end
-      end
-    end
-  end
-end
+# FilterBase is a historical alias for Omnizip::Filter. New code should
+# inherit from Omnizip::Filter directly; FilterBase is kept for
+# backward compatibility with existing subclasses (BcjX86, BcjArm, …).
+Omnizip::Filters::FilterBase = Omnizip::Filter

data/lib/omnizip/filters/registry.rb

@@ -16,8 +16,6 @@
 # See the COPYING file for the complete text of the license.
 #
 
-require "omnizip/filters"
-
 module Omnizip
   module Filters
     # Registry for auto-registering all preprocessing filters.

data/lib/omnizip/format_detector.rb

@@ -104,23 +104,32 @@ module Omnizip
       detect(file_path) == :rar4
     end
 
+    # Mapping of detected format symbols to (extension, constant-path)
+    # tuples. The constant path is resolved lazily so autoload fires
+    # only when a format is actually requested.
+    READER_FOR_FORMAT = {
+      xz: ["omnizip/formats/xz", "Omnizip::Formats::Xz"],
+      seven_zip: ["omnizip/formats/seven_zip", "Omnizip::Formats::SevenZip::Reader"],
+      rar5: ["omnizip/formats/rar5", "Omnizip::Formats::Rar5::Reader"],
+      rar4: ["omnizip/formats/rar3", "Omnizip::Formats::Rar3::Reader"],
+      zip: ["omnizip/formats/zip", "Omnizip::Formats::Zip::Reader"],
+      gzip: ["omnizip/formats/gzip", "Omnizip::Formats::Gzip"],
+      bzip2: ["omnizip/formats/bzip2_file", "Omnizip::Formats::Bzip2File"],
+    }.freeze
+
     # Get the appropriate reader class for the format
     #
     # @param file_path [String] Path to the archive file
     # @return [Class, nil] Reader class or nil if unknown format
     def self.reader_for(file_path)
-      case detect(file_path)
-      when :xz
-        Omnizip::Formats::Xz
-      when :seven_zip
-        Omnizip::Formats::SevenZip::Reader
-      when :rar5
-        Omnizip::Formats::Rar5::Reader
-      when :rar4
-        Omnizip::Formats::Rar3::Reader
-      when :zip
-        Omnizip::Formats::Zip::Reader
-      end
+      format = detect(file_path)
+      return nil unless format
+
+      mapping = READER_FOR_FORMAT[format]
+      return nil unless mapping
+
+      _path, const_path = mapping
+      Object.const_get(const_path)
     end
 
     # Detect LZMA_Alone format

data/lib/omnizip/format_registry.rb

@@ -1,42 +1,71 @@
 # frozen_string_literal: true
 
 module Omnizip
-  # Registry for archive format handlers
-  # Manages different archive format readers (7z, zip, tar, etc.)
-  class FormatRegistry
+  class FormatRegistry < Omnizip::Registry
+    BUILTIN_FORMATS = {
+      ".7z" => "Omnizip::Formats::SevenZip::Reader",
+      ".zip" => "Omnizip::Formats::Zip",
+      ".rar" => "Omnizip::Formats::Rar::Reader",
+      ".tar" => "Omnizip::Formats::Tar",
+      ".gz" => "Omnizip::Formats::Gzip",
+      ".gzip" => "Omnizip::Formats::Gzip",
+      ".bz2" => "Omnizip::Formats::Bzip2File",
+      ".bzip2" => "Omnizip::Formats::Bzip2File",
+      ".xz" => "Omnizip::Formats::Xz",
+      ".msi" => "Omnizip::Formats::Msi",
+      ".msp" => "Omnizip::Formats::Msi",
+      ".cpio" => "Omnizip::Formats::Cpio::Reader",
+      ".iso" => "Omnizip::Formats::Iso::Reader",
+      ".xar" => "Omnizip::Formats::Xar::Reader",
+      ".lz" => "Omnizip::Formats::Lzip",
+      ".lzip" => "Omnizip::Formats::Lzip",
+      ".lzma" => "Omnizip::Formats::LzmaAlone",
+      ".ole" => "Omnizip::Formats::Ole::Storage",
+      ".doc" => "Omnizip::Formats::Ole::Storage",
+      ".xls" => "Omnizip::Formats::Ole::Storage",
+      ".ppt" => "Omnizip::Formats::Ole::Storage",
+    }.freeze
+
     class << self
-      # Register a format handler
-      #
-      # @param extension [String] File extension (e.g., ".7z", ".zip")
-      # @param handler_class [Class, String] Format handler class or class name string
-      def register(extension, handler_class)
-        registry[normalize_extension(extension)] = handler_class
+      def label
+        "Format"
+      end
+
+      def normalize_key(extension)
+        ext = extension.to_s
+        ext = ".#{ext}" unless ext.start_with?(".")
+        ext.downcase
       end
 
-      # Get format handler for extension
-      #
-      # @param extension [String] File extension
-      # @return [Class, Module, nil] Handler class/module or nil if not found
       def get(extension)
-        handler = registry[normalize_extension(extension)]
-        return handler if handler.nil? || handler.is_a?(Class) || handler.is_a?(Module)
+        normalized = normalize_key(extension)
+        handler = storage[normalized]
+        return resolve_handler(handler, extension) if handler
 
-        # Resolve string to class if needed
-        resolve_constant(handler)
+        trigger = lazy_triggers[normalized]
+        if trigger
+          synchronize { lazy_triggers.delete(normalized) }
+          trigger.call
+          handler = storage[normalized]
+          return resolve_handler(handler, extension) if handler
+        end
+
+        nil
+      end
+
+      def supported?(extension)
+        registered?(extension) || lazy_triggers.key?(normalize_key(extension))
       end
+      alias supported_formats available
 
-      # Resolve a string to a constant (class/module)
-      #
-      # @param name [String] Fully qualified class name
-      # @return [Class, Module, nil] Resolved constant or nil
       def resolve_constant(name)
         return nil unless name.is_a?(String)
 
-        names = name.split("::")
-        names.shift if names.empty? || names.first.empty?
+        parts = name.split("::")
+        parts.shift if parts.empty? || parts.first.empty?
 
         constant = Object
-        names.each do |n|
+        parts.each do |n|
           return nil unless constant.const_defined?(n, false)
 
           constant = constant.const_get(n)
@@ -46,39 +75,26 @@ module Omnizip
         nil
       end
 
-      # Check if format is supported
-      #
-      # @param extension [String] File extension
-      # @return [Boolean] true if supported
-      def supported?(extension)
-        registry.key?(normalize_extension(extension))
-      end
-
-      # List all supported formats
-      #
-      # @return [Array<String>] Supported extensions
-      def supported_formats
-        registry.keys.sort
-      end
-
       private
 
-      # Format registry storage
-      #
-      # @return [Hash] Extension to handler class mapping
-      def registry
-        @registry ||= {}
-      end
+      def resolve_handler(handler, _original_extension)
+        return nil if handler.nil?
+        return handler if handler.is_a?(Class) || handler.is_a?(Module)
 
-      # Normalize file extension
-      #
-      # @param ext [String] Extension
-      # @return [String] Normalized extension
-      def normalize_extension(ext)
-        ext = ext.to_s
-        ext = ".#{ext}" unless ext.start_with?(".")
-        ext.downcase
+        resolve_constant(handler)
       end
     end
   end
 end
+
+# Lazy triggers — explicitly re-register on each miss so the entry
+# survives reset!. Object.const_get alone doesn't re-run the file body
+# once the constant is loaded.
+Omnizip::FormatRegistry::BUILTIN_FORMATS.each do |ext, const_path|
+  Omnizip::FormatRegistry.register_lazy(ext) do
+    handler = Object.const_get(const_path)
+    # Register under the original extension; some formats (e.g. Rar)
+    # store a string class path that needs resolve_constant on get.
+    Omnizip::FormatRegistry.register(ext, handler)
+  end
+end

data/lib/omnizip/formats/bzip2_file.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "stringio"
-require "omnizip/algorithm_registry"
 
 module Omnizip
   module Formats
@@ -115,7 +114,6 @@ module Omnizip
 
         # Register BZIP2 format when loaded
         def register!
-          require "omnizip/format_registry"
           FormatRegistry.register(".bz2", Omnizip::Formats::Bzip2File)
           FormatRegistry.register(".bzip2", Omnizip::Formats::Bzip2File)
         end

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

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "omnizip/formats/cpio"
-
 module Omnizip
   module Formats
     module Cpio

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require "omnizip/formats/cpio"
 
 module Omnizip
   module Formats

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "fileutils"
-require "omnizip/formats/cpio"
 
 module Omnizip
   module Formats

data/lib/omnizip/formats/cpio.rb

@@ -129,7 +129,6 @@ module Omnizip
 
         # Auto-register CPIO format when loaded
         def register!
-          require "omnizip/format_registry"
           FormatRegistry.register(".cpio", Reader)
         end
       end

data/lib/omnizip/formats/format_spec_loader.rb

@@ -200,7 +200,7 @@ module Omnizip
       # @param key [Symbol, String] The key to retrieve
       # @return [Object] The value for the key
       def [](key)
-        format.send(key)
+        format.public_send(key)
       end
 
       # Get magic bytes as an array of integers

data/lib/omnizip/formats/gzip.rb

@@ -2,7 +2,6 @@
 
 require "zlib"
 require "stringio"
-require "omnizip/algorithm_registry"
 
 module Omnizip
   module Formats
@@ -130,7 +129,6 @@ module Omnizip
 
         # Register GZIP format when loaded
         def register!
-          require "omnizip/format_registry"
           FormatRegistry.register(".gz", Omnizip::Formats::Gzip)
           FormatRegistry.register(".gzip", Omnizip::Formats::Gzip)
         end

data/lib/omnizip/formats/iso/directory_record.rb

@@ -6,9 +6,12 @@ module Omnizip
       # ISO 9660 Directory Record
       # Represents a file or directory entry
       class DirectoryRecord
-        attr_reader :length, :extended_attr_length, :location, :data_length,
-                    :recording_date, :flags, :file_unit_size, :interleave_gap_size,
-                    :volume_sequence_number, :name, :system_use
+        attr_accessor :full_path
+        attr_reader :length, :extended_attr_length, :location, :data_length, :recording_date, :flags, :file_unit_size, :interleave_gap_size, :volume_sequence_number, :name, :system_use
+
+        # Set the full path for this record, used by Reader when walking
+        # a directory tree. Allows callers to look up records by path
+        # without re-joining parent names.
 
         # Parse directory record from binary data
         #

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

@@ -158,7 +158,7 @@ module Omnizip
             unless record.current_directory? || record.parent_directory?
               # Set full path
               full_path = path_prefix.empty? ? record.name : "#{path_prefix}/#{record.name}"
-              record.instance_variable_set(:@full_path, full_path)
+              record.full_path = full_path
 
               @entries << record
 
@@ -177,7 +177,7 @@ module Omnizip
         def find_entry(path)
           # Normalize path
           path = path.gsub(%r{^/+}, "").gsub(%r{/+$}, "")
-          @entries.find { |e| e.instance_variable_get(:@full_path) == path }
+          @entries.find { |e| e.full_path == path }
         end
 
         # Read file data

data/lib/omnizip/formats/iso.rb

@@ -130,7 +130,6 @@ module Omnizip
 
       # Auto-register ISO format when loaded
       def self.register!
-        require "omnizip/format_registry"
         FormatRegistry.register(".iso", Reader)
       end
     end