cabriolet 0.1.2 → 0.2.1

data/lib/cabriolet/oab/compressor.rb

@@ -32,8 +32,10 @@ module Cabriolet
       # Initialize OAB compressor
       #
       # @param io_system [System::IOSystem, nil] I/O system or nil for default
-      def initialize(io_system = nil)
+      # @param algorithm_factory [AlgorithmFactory, nil] Custom algorithm factory or nil for default
+      def initialize(io_system = nil, algorithm_factory = nil)
         @io_system = io_system || System::IOSystem.new
+        @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
         @buffer_size = DEFAULT_BUFFER_SIZE
         @block_size = DEFAULT_BLOCK_SIZE
       end
@@ -47,7 +49,7 @@ module Cabriolet
       # @return [Integer] Bytes written
       # @raise [Error] if compression fails
       def compress(input_file, output_file, **options)
-        block_size = options.fetch(:block_size, @block_size)
+        block_size = options[:block_size] || @block_size
 
         input_handle = @io_system.open(input_file, Constants::MODE_READ)
         output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
@@ -93,7 +95,7 @@ module Cabriolet
       # @return [Integer] Bytes written
       # @raise [Error] if compression fails
       def compress_data(data, output_file, **options)
-        block_size = options.fetch(:block_size, @block_size)
+        block_size = options[:block_size] || @block_size
 
         input_handle = System::MemoryHandle.new(data, Constants::MODE_READ)
         output_handle = @io_system.open(output_file, Constants::MODE_WRITE)
@@ -138,7 +140,7 @@ module Cabriolet
       # @return [Integer] Bytes written
       # @raise [Error] if compression fails
       def compress_incremental(input_file, base_file, output_file, **options)
-        block_size = options.fetch(:block_size, @block_size)
+        block_size = options[:block_size] || @block_size
 
         # For now, just compress the new file with patch header
         # A full implementation would generate binary diffs
@@ -249,7 +251,8 @@ module Cabriolet
         compressed_data = compress_with_lzx(block_data)
 
         # Use compressed data (or original if compression fails)
-        patch_data = compressed_data && compressed_data.bytesize < block_data.bytesize ? compressed_data : block_data
+        is_compressed = compressed_data && compressed_data.bytesize < block_data.bytesize
+        patch_data = is_compressed ? compressed_data : block_data
         patch_size = patch_data.bytesize
 
         # Calculate CRC
@@ -257,6 +260,7 @@ module Cabriolet
 
         # Write patch block header
         block_header = Binary::OABStructures::PatchBlockHeader.new
+        block_header.flags = is_compressed ? 1 : 0
         block_header.patch_size = patch_size
         block_header.target_size = block_size
         block_header.source_size = source_size
@@ -287,9 +291,14 @@ module Cabriolet
         output_mem = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
         # Compress with LZX
-        compressor = Compressors::LZX.new(
-          @io_system, input_mem, output_mem, @buffer_size,
-          window_bits: window_bits
+        compressor = @algorithm_factory.create(
+          Constants::COMP_TYPE_LZX,
+          :compressor,
+          @io_system,
+          input_mem,
+          output_mem,
+          @buffer_size,
+          window_bits: window_bits,
         )
 
         compressor.compress

data/lib/cabriolet/oab/decompressor.rb

@@ -25,8 +25,10 @@ module Cabriolet
       # Initialize OAB decompressor
       #
       # @param io_system [System::IOSystem, nil] I/O system or nil for default
-      def initialize(io_system = nil)
+      # @param algorithm_factory [AlgorithmFactory, nil] Custom algorithm factory or nil for default
+      def initialize(io_system = nil, algorithm_factory = nil)
         @io_system = io_system || System::IOSystem.new
+        @algorithm_factory = algorithm_factory || Cabriolet.algorithm_factory
         @buffer_size = DEFAULT_BUFFER_SIZE
       end
 
@@ -161,9 +163,9 @@ target_remaining)
       # @return [Integer] Bytes written
       def decompress_patch_block(patch_handle, base_handle, output_handle,
                                  block_max, target_remaining)
-        # Read patch block header
-        block_data = @io_system.read(patch_handle, 16)
-        if block_data.length < 16
+        # Read patch block header (20 bytes with flags field)
+        block_data = @io_system.read(patch_handle, 20)
+        if block_data.length < 20
           raise Error,
                 "Failed to read patch block header"
         end
@@ -177,6 +179,25 @@ target_remaining)
           raise Error, "Invalid patch block header"
         end
 
+        # Check if data is compressed or uncompressed
+        if block_header.uncompressed?
+          # Uncompressed data - read and write directly
+          data = @io_system.read(patch_handle, block_header.patch_size)
+          if data.length < block_header.patch_size
+            raise Error, "Failed to read uncompressed patch data"
+          end
+
+          # Verify CRC
+          actual_crc = Zlib.crc32(data)
+          if actual_crc != block_header.crc
+            raise Error, "CRC mismatch in patch block"
+          end
+
+          @io_system.write(output_handle, data)
+          return block_header.target_size
+        end
+
+        # Compressed data - use LZX decompression
         # Calculate window size for LZX
         window_size = ((block_header.source_size + 32_767) & ~32_767) +
           block_header.target_size
@@ -245,12 +266,17 @@ target_remaining)
         output_mem = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
         # Decompress with LZX
-        lzx = Decompressors::LZX.new(
-          @io_system, input_mem, output_mem, @buffer_size,
+        lzx = @algorithm_factory.create(
+          Constants::COMP_TYPE_LZX,
+          :decompressor,
+          @io_system,
+          input_mem,
+          output_mem,
+          @buffer_size,
           window_bits: window_bits,
           reset_interval: 0,
           output_length: block_size,
-          is_delta: false
+          is_delta: false,
         )
 
         bytes_decompressed = lzx.decompress(block_size)
@@ -286,12 +312,17 @@ target_remaining)
         output_mem = System::MemoryHandle.new("", Constants::MODE_WRITE)
 
         # Decompress with LZX DELTA (includes reference data)
-        lzx = Decompressors::LZX.new(
-          @io_system, input_mem, output_mem, @buffer_size,
+        lzx = @algorithm_factory.create(
+          Constants::COMP_TYPE_LZX,
+          :decompressor,
+          @io_system,
+          input_mem,
+          output_mem,
+          @buffer_size,
           window_bits: window_bits,
           reset_interval: 0,
           output_length: block_header.target_size,
-          is_delta: true
+          is_delta: true,
         )
 
         # For patches, we'd need to set reference data in the LZX window

data/lib/cabriolet/offset_calculator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  # Abstract base class for offset calculators
+  #
+  # Single responsibility: Calculate file positions within archive.
+  # Strategy pattern: Different formats implement different calculation strategies.
+  #
+  # Subclasses must implement:
+  # - calculate(structure) - Returns hash of offsets
+  #
+  # @example Creating a calculator
+  #   class MyFormatCalculator < OffsetCalculator
+  #     def calculate(structure)
+  #       { header: 0, data: 100 }
+  #     end
+  #   end
+  class OffsetCalculator
+    # Calculate all offsets in archive structure
+    #
+    # @param structure [Hash] Archive structure with files, folders, etc.
+    # @return [Hash] Offset information
+    # @raise [NotImplementedError] if not implemented by subclass
+    def calculate(structure)
+      raise NotImplementedError,
+            "#{self.class.name} must implement calculate(structure)"
+    end
+
+    protected
+
+    # Helper: Calculate cumulative offsets for items
+    #
+    # @param items [Array] Items to calculate offsets for
+    # @param initial_offset [Integer] Starting offset
+    # @yield [item] Block that returns size for each item
+    # @return [Array<Hash>] Items with their offsets
+    def cumulative_offsets(items, initial_offset = 0)
+      offset = initial_offset
+      items.map do |item|
+        current_offset = offset
+        item_size = yield(item)
+        offset += item_size
+        { item: item, offset: current_offset, size: item_size }
+      end
+    end
+  end
+
+  # CAB-specific offset calculator
+  #
+  # Calculates offsets for CFHEADER, CFFOLDER entries, CFFILE entries,
+  # and CFDATA blocks in Microsoft Cabinet files.
+  class CABOffsetCalculator < OffsetCalculator
+    # Calculate CAB file offsets
+    #
+    # @param structure [Hash] Must contain :folders and :files
+    # @return [Hash] Offset information
+    def calculate(structure)
+      offset = Constants::CFHEADER_SIZE
+
+      # Folders section
+      folders_offset = offset
+      offset += Constants::CFFOLDER_SIZE * structure[:folders].size
+
+      # Files section
+      files_offset = offset
+      structure[:files].each do |file_info|
+        offset += Constants::CFFILE_SIZE
+        offset += file_info[:name].bytesize + 1 # null-terminated
+      end
+
+      # Data blocks section
+      data_offset = offset
+
+      {
+        folders: folders_offset,
+        files: files_offset,
+        data: data_offset,
+      }
+    end
+  end
+end

data/lib/cabriolet/plugin.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+
+module Cabriolet
+  # Base class for all Cabriolet plugins
+  #
+  # Plugins extend Cabriolet's functionality by providing custom compression
+  # algorithms, format handlers, or other enhancements. All plugins must
+  # inherit from this base class and implement required methods.
+  #
+  # @abstract Subclass and implement {#metadata} and {#setup} to create
+  #   a plugin
+  #
+  # @example Creating a simple plugin
+  #   class MyPlugin < Cabriolet::Plugin
+  #     def metadata
+  #       {
+  #         name: "my-plugin",
+  #         version: "1.0.0",
+  #         author: "Your Name",
+  #         description: "Adds custom compression algorithm",
+  #         cabriolet_version: "~> 0.1"
+  #       }
+  #     end
+  #
+  #     def setup
+  #       register_algorithm(:custom, CustomAlgorithm,
+  #                         category: :compressor)
+  #     end
+  #   end
+  class Plugin
+    # Plugin states
+    STATES = %i[discovered loaded active failed disabled].freeze
+
+    # @return [Symbol] Current plugin state
+    attr_reader :state
+
+    # Initialize a new plugin
+    #
+    # @param manager [PluginManager] The plugin manager instance
+    def initialize(manager = nil)
+      @manager = manager
+      @state = :discovered
+    end
+
+    # Get plugin metadata
+    #
+    # @abstract Must be implemented by subclasses
+    #
+    # @return [Hash] Plugin metadata containing:
+    # @option return [String] :name Plugin name (required)
+    # @option return [String] :version Plugin version (required)
+    # @option return [String] :author Plugin author (required)
+    # @option return [String] :description Plugin description (required)
+    # @option return [String] :cabriolet_version Compatible Cabriolet
+    #   version (required)
+    # @option return [String] :homepage Plugin homepage URL (optional)
+    # @option return [String] :license Plugin license (optional)
+    # @option return [Array<String>] :dependencies Plugin dependencies
+    #   (optional)
+    # @option return [Array<String>] :tags Search tags (optional)
+    # @option return [Hash] :provides What the plugin provides (optional)
+    #
+    # @raise [NotImplementedError] If not implemented by subclass
+    #
+    # @example Minimal metadata
+    #   def metadata
+    #     {
+    #       name: "my-plugin",
+    #       version: "1.0.0",
+    #       author: "Your Name",
+    #       description: "Plugin description",
+    #       cabriolet_version: "~> 0.1"
+    #     }
+    #   end
+    #
+    # @example Full metadata
+    #   def metadata
+    #     {
+    #       name: "advanced-plugin",
+    #       version: "2.0.0",
+    #       author: "Developer",
+    #       description: "Advanced features",
+    #       cabriolet_version: ">= 0.1.0",
+    #       homepage: "https://example.com",
+    #       license: "MIT",
+    #       dependencies: ["other-plugin >= 1.0"],
+    #       tags: ["compression", "algorithm"],
+    #       provides: { algorithms: [:custom], formats: [:special] }
+    #     }
+    #   end
+    def metadata
+      raise NotImplementedError,
+            "#{self.class} must implement metadata method"
+    end
+
+    # Setup the plugin
+    #
+    # Called when the plugin is loaded. Use this method to register
+    # algorithms, formats, or perform other initialization tasks.
+    #
+    # @abstract Must be implemented by subclasses
+    #
+    # @raise [NotImplementedError] If not implemented by subclass
+    #
+    # @example Register an algorithm
+    #   def setup
+    #     register_algorithm(:myalgo, MyAlgorithm,
+    #                       category: :compressor)
+    #   end
+    #
+    # @example Register multiple items
+    #   def setup
+    #     register_algorithm(:algo1, Algo1, category: :compressor)
+    #     register_algorithm(:algo2, Algo2, category: :decompressor)
+    #     register_format(:myformat, MyFormatHandler)
+    #   end
+    def setup
+      raise NotImplementedError,
+            "#{self.class} must implement setup method"
+    end
+
+    # Activate the plugin
+    #
+    # Called when the plugin is activated. Override to perform actions
+    # when the plugin becomes active.
+    #
+    # @return [void]
+    #
+    # @example Add hooks on activation
+    #   def activate
+    #     puts "#{metadata[:name]} activated"
+    #     # Additional activation logic...
+    #   end
+    def activate
+      # Default implementation does nothing
+    end
+
+    # Deactivate the plugin
+    #
+    # Called when the plugin is deactivated. Override to perform cleanup
+    # when the plugin is deactivated.
+    #
+    # @return [void]
+    #
+    # @example Cleanup on deactivation
+    #   def deactivate
+    #     # Cleanup resources...
+    #     puts "#{metadata[:name]} deactivated"
+    #   end
+    def deactivate
+      # Default implementation does nothing
+    end
+
+    # Cleanup the plugin
+    #
+    # Called when the plugin is unloaded. Override to perform final
+    # cleanup tasks.
+    #
+    # @return [void]
+    #
+    # @example Final cleanup
+    #   def cleanup
+    #     # Release resources...
+    #     # Close connections...
+    #   end
+    def cleanup
+      # Default implementation does nothing
+    end
+
+    protected
+
+    # Register a compression or decompression algorithm
+    #
+    # @param type [Symbol] Algorithm type identifier
+    # @param klass [Class] Algorithm class
+    # @param options [Hash] Registration options
+    # @option options [Symbol] :category Required - :compressor or
+    #   :decompressor
+    # @option options [Integer] :priority Algorithm priority (default: 0)
+    # @option options [Symbol, nil] :format Format restriction (optional)
+    #
+    # @return [void]
+    #
+    # @raise [PluginError] If manager is not available
+    #
+    # @example Register a compressor
+    #   register_algorithm(:myalgo, MyCompressor,
+    #                     category: :compressor, priority: 10)
+    #
+    # @example Register a format-specific decompressor
+    #   register_algorithm(:special, SpecialDecompressor,
+    #                     category: :decompressor, format: :cab)
+    def register_algorithm(type, klass, **options)
+      raise PluginError, "Plugin manager not available" unless @manager
+
+      Cabriolet.algorithm_factory.register(type, klass, **options)
+    end
+
+    # Register a format handler
+    #
+    # @param format [Symbol] Format identifier
+    # @param handler [Class] Format handler class
+    #
+    # @return [void]
+    #
+    # @raise [PluginError] If manager is not available
+    #
+    # @example Register a format handler
+    #   register_format(:myformat, MyFormatHandler)
+    def register_format(format, handler)
+      raise PluginError, "Plugin manager not available" unless @manager
+
+      # Format registration will be implemented when format registry exists
+      # For now, store in manager's format registry
+      @manager.register_format(format, handler)
+    end
+
+    # Update plugin state
+    #
+    # @param new_state [Symbol] New state (must be in STATES)
+    #
+    # @return [void]
+    #
+    # @raise [ArgumentError] If state is invalid
+    def update_state(new_state)
+      unless STATES.include?(new_state)
+        raise ArgumentError, "Invalid state: #{new_state}"
+      end
+
+      @state = new_state
+    end
+  end
+end