omnizip 0.3.9 → 0.3.10

data/lib/omnizip/implementations/seven_zip/lzma/range_decoder.rb

@@ -74,14 +74,14 @@ module Omnizip
               # UPDATE_0: bit is 0
               @range = bound & 0xFFFFFFFF
               new_prob = prob + ((BIT_MODEL_TOTAL - prob) >> MOVE_BITS)
-              model.instance_variable_set(:@probability, new_prob)
+              model.probability = new_prob
               0
             else
               # UPDATE_1: bit is 1
               @range = (@range - bound) & 0xFFFFFFFF
               @code = (@code - bound) & 0xFFFFFFFF
               new_prob = prob - (prob >> MOVE_BITS)
-              model.instance_variable_set(:@probability, new_prob)
+              model.probability = new_prob
               1
             end
           end

data/lib/omnizip/implementations/seven_zip/lzma/range_encoder.rb

@@ -91,7 +91,7 @@ module Omnizip
                          # Update probability: ttt -= ttt >> kNumMoveBits
                          prob - (prob >> MOVE_BITS)
                        end
-            model.instance_variable_set(:@probability, new_prob)
+            model.probability = new_prob
 
             # RC_NORM: Normalize AFTER encoding (key SDK difference!)
             normalize

data/lib/omnizip/implementations/seven_zip/lzma2/encoder.rb

@@ -71,12 +71,6 @@ module Omnizip
 
             # Initialize shared state across all chunks
             # Using XZ Utils components (tested and working)
-            require "omnizip/algorithms/lzma/dictionary"
-            require "omnizip/algorithms/lzma/lzma_state"
-            require "omnizip/algorithms/lzma/xz_probability_models"
-            require "omnizip/algorithms/lzma/match_finder"
-            require "omnizip/algorithms/lzma/optimal_encoder"
-            require "omnizip/algorithms/lzma/xz_range_encoder_exact"
 
             @dictionary = Omnizip::Algorithms::LZMA::Dictionary.new(dict_size)
             @state = Omnizip::Algorithms::LZMA::LZMAState.new(0)

data/lib/omnizip/implementations/xz_utils/lzma2/decoder.rb

@@ -21,7 +21,6 @@
 # DEALINGS IN THE SOFTWARE.
 
 require "stringio"
-require "omnizip/algorithms"
 
 module Omnizip
   module Implementations
@@ -418,10 +417,10 @@ module Omnizip
                 if @lzma2_debug
                   warn "DEBUG: decompress_lzma_chunk - After set_input, checking range_decoder..."
                   # Check if the decoder has a range_decoder variable
-                  if @lzma_decoder.instance_variable_defined?(:@range_decoder)
-                    range_decoder = @lzma_decoder.instance_variable_get(:@range_decoder)
+                  if @lzma_decoder.respond_to?(:range_decoder)
+                    range_decoder = @lzma_decoder.range_decoder
                     if range_decoder
-                      warn "  range_decoder exists: code=0x#{range_decoder.instance_variable_get(:@code).to_s(16)}, range=0x#{range_decoder.instance_variable_get(:@range).to_s(16)}, init_bytes_remaining=#{range_decoder.instance_variable_get(:@init_bytes_remaining)}"
+                      warn "  range_decoder exists: code=0x#{range_decoder.code.to_s(16)}, range=0x#{range_decoder.range.to_s(16)}, init_bytes_remaining=#{range_decoder.init_bytes_remaining}"
                     else
                       warn "  range_decoder is nil"
                     end

data/lib/omnizip/implementations/xz_utils/lzma2/encoder.rb

@@ -21,7 +21,6 @@
 # DEALINGS IN THE SOFTWARE.
 
 require "stringio"
-require "omnizip/implementations/base"
 
 module Omnizip
   module Implementations

data/lib/omnizip/io/source.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module IO
+    # Polymorphic adapter for "things we can read bytes from".
+    #
+    # Callers that previously did:
+    #
+    #     data = input.respond_to?(:read) ? input.read : File.binread(input)
+    #
+    # should now do:
+    #
+    #     data = Omnizip::IO::Source.for(input).read
+    #
+    # Adapters:
+    # - +IO+/+StringIO+/+Tempfile+ → wrapped as-is
+    # - +String+ → treated as a file path; read with +File.binread+
+    #   unless the string contains no NUL bytes and does not exist on
+    #   disk, in which case it is treated as literal data
+    # - +Object+ responding to +:read+ → delegated to
+    class Source
+      # Build a Source wrapper appropriate for +input+.
+      #
+      # @param input [IO, StringIO, String, #read] the read target
+      # @return [Source]
+      def self.for(input)
+        case input
+        when ::IO, ::StringIO, ::Tempfile then new(input)
+        when String then StringSource.new(input)
+        else
+          unless input.respond_to?(:read)
+            raise ArgumentError,
+                  "Cannot adapt #{input.inspect} to Omnizip::IO::Source"
+          end
+
+          new(input)
+        end
+      end
+
+      def initialize(io)
+        @io = io
+      end
+
+      # Delegate reading to the underlying IO-like object.
+      def read(length = nil, outbuf = nil)
+        if length.nil?
+          @io.read
+        elsif outbuf
+          @io.read(length, outbuf)
+        else
+          @io.read(length)
+        end
+      end
+
+      def close
+        @io.close if @io.respond_to?(:close)
+      end
+
+      # String input adapter. Treats the value as a file path if it
+      # exists on disk and contains no NUL bytes, otherwise as raw
+      # bytes.
+      class StringSource < Source
+        def initialize(value)
+          super(nil)
+          @value = value
+        end
+
+        def read(_length = nil, _outbuf = nil)
+          if file_path?
+            File.binread(@value)
+          else
+            @value.b
+          end
+        end
+
+        def close; end
+
+        private
+
+        def file_path?
+          !@value.include?("\0") && File.exist?(@value)
+        end
+      end
+    end
+
+    # Polymorphic adapter for "things we can write bytes to".
+    #
+    # Adapters:
+    # - +IO+/+StringIO+/+Tempfile+ → wrapped as-is
+    # - +String+ → treated as a file path; writes via +File.binwrite+
+    # - +Object+ responding to +:write+ → delegated to
+    class Sink
+      def self.for(output)
+        case output
+        when ::IO, ::StringIO, ::Tempfile then new(output)
+        when String then PathSink.new(output)
+        else
+          unless output.respond_to?(:write)
+            raise ArgumentError,
+                  "Cannot adapt #{output.inspect} to Omnizip::IO::Sink"
+          end
+
+          new(output)
+        end
+      end
+
+      def initialize(io)
+        @io = io
+      end
+
+      def write(data)
+        @io.write(data)
+      end
+
+      def close
+        @io.close if @io.respond_to?(:close)
+      end
+
+      # File-path sink: opens the file for binary write on #write and
+      # closes after.
+      class PathSink < Sink
+        def initialize(path)
+          super(nil)
+          @path = path
+          @file = nil
+        end
+
+        def write(data)
+          File.binwrite(@path, data)
+        end
+
+        def close; end
+      end
+    end
+  end
+end

data/lib/omnizip/io.rb

@@ -9,5 +9,7 @@ module Omnizip
     autoload :BufferedInput, "omnizip/io/buffered_input"
     autoload :BufferedOutput, "omnizip/io/buffered_output"
     autoload :StreamManager, "omnizip/io/stream_manager"
+    autoload :Source, "omnizip/io/source"
+    autoload :Sink, "omnizip/io/source"
   end
 end

data/lib/omnizip/link_handler.rb

@@ -11,14 +11,18 @@ module Omnizip
         !windows_platform?
       end
 
-      # Check if symbolic links are supported
+      # Check if symbolic links are supported on this platform.
+      # Delegates to Platform but also gates on LinkHandler#supported?
+      # (Windows is treated as unsupported here for historical
+      # compatibility — even if Windows Developer Mode would allow
+      # symlinks, callers should opt into that explicitly via Platform).
       def symlink_supported?
-        File.respond_to?(:symlink) && supported?
+        supported? && Omnizip::Platform.supports_symlinks?
       end
 
       # Check if hard links are supported
       def hardlink_supported?
-        File.respond_to?(:link) && supported?
+        supported? && Omnizip::Platform.supports_hardlinks?
       end
 
       # Detect if a path is a symbolic link

data/lib/omnizip/metadata/metadata_editor.rb

@@ -160,7 +160,7 @@ module Omnizip
       def commit
         # Changes are already applied to entries
         # Just mark archive as modified
-        archive.instance_variable_set(:@modified, true) if modified?
+        archive.modified! if modified?
         @changes = []
         self
       end

data/lib/omnizip/models/algorithm_metadata.rb

@@ -1,72 +1,45 @@
 # 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.
-#
-
-require "json"
+require "lutaml/model"
 
 module Omnizip
   module Models
-    # Model representing metadata about a compression algorithm.
+    # Metadata describing a compression algorithm.
     #
-    # This class encapsulates information about a compression algorithm,
-    # including its name, description, version, and capabilities.
-    class AlgorithmMetadata
-      attr_accessor :name, :description, :version, :author,
-                    :max_compression_level, :min_compression_level,
-                    :default_compression_level, :supports_streaming,
-                    :supports_multithreading
-
-      def initialize(**kwargs)
-        @supports_streaming = false
-        @supports_multithreading = false
-
-        kwargs.each do |key, value|
-          instance_variable_set("@#{key}", value)
-        end
-      end
-
-      def to_h
-        {
-          name: @name,
-          description: @description,
-          version: @version,
-          author: @author,
-          max_compression_level: @max_compression_level,
-          min_compression_level: @min_compression_level,
-          default_compression_level: @default_compression_level,
-          supports_streaming: @supports_streaming,
-          supports_multithreading: @supports_multithreading,
-        }.compact
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    class AlgorithmMetadata < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :description, :string
+      attribute :version, :string
+      attribute :author, :string
+      attribute :max_compression_level, :integer
+      attribute :min_compression_level, :integer
+      attribute :default_compression_level, :integer
+      attribute :supports_streaming, :boolean, default: false
+      attribute :supports_multithreading, :boolean, default: false
+
+      json do
+        map :name, to: :name
+        map :description, to: :description
+        map :version, to: :version
+        map :author, to: :author
+        map :max_compression_level, to: :max_compression_level
+        map :min_compression_level, to: :min_compression_level
+        map :default_compression_level, to: :default_compression_level
+        map :supports_streaming, to: :supports_streaming
+        map :supports_multithreading, to: :supports_multithreading
       end
 
-      # Serialize to JSON
+      # Apply a hash of attributes (whitelisted to declared attributes).
       #
-      # @return [String] JSON representation
-      def to_json(*args)
-        to_h.to_json(*args)
-      end
-
-      # Deserialize from JSON
-      #
-      # @param json [String] JSON string
-      # @return [AlgorithmMetadata] Deserialized instance
-      def self.from_json(json)
-        data = JSON.parse(json)
-        new(**data.transform_keys(&:to_sym))
+      # @param attributes [Hash{Symbol=>Object}]
+      # @return [self]
+      def apply(attributes)
+        self.class.attributes.each do |attr|
+          name = attr.name
+          public_send("#{name}=", attributes[name]) if attributes.key?(name)
+        end
+        self
       end
     end
   end

data/lib/omnizip/models/compression_options.rb

@@ -1,70 +1,57 @@
 # 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.
-#
-
+require "lutaml/model"
 require "json"
 
 module Omnizip
   module Models
     # Model representing compression operation options.
     #
-    # This class encapsulates configuration options for compression
-    # operations, including compression level, threading, and buffer sizes.
-    class CompressionOptions
-      attr_accessor :level, :dictionary_size, :num_fast_bytes, :match_finder,
-                    :num_threads, :solid, :buffer_size
-
-      def initialize(**kwargs)
-        @level = 5
-        @num_threads = 1
-        @solid = false
-        @buffer_size = 65_536
-
-        kwargs.each do |key, value|
-          instance_variable_set("@#{key}", value)
-        end
+    # Serialized via lutaml-model — callers should not write hand-rolled
+    # +to_h+ / +to_json+ / +from_json+ on this class. The framework
+    # provides +#to_hash+, +#to_json+, and +.from_hash+ / +.from_json+
+    # automatically from the +attribute+ declarations below.
+    class CompressionOptions < Lutaml::Model::Serializable
+      attribute :level, :integer, default: 5
+      attribute :dictionary_size, :integer
+      attribute :num_fast_bytes, :integer
+      attribute :match_finder, :string
+      attribute :num_threads, :integer, default: 1
+      attribute :solid, :boolean, default: false
+      attribute :buffer_size, :integer, default: 65_536
+
+      # JSON / hash mappings (1:1, no renames needed).
+      json do
+        map :level, to: :level
+        map :dictionary_size, to: :dictionary_size
+        map :num_fast_bytes, to: :num_fast_bytes
+        map :match_finder, to: :match_finder
+        map :num_threads, to: :num_threads
+        map :solid, to: :solid
+        map :buffer_size, to: :buffer_size
       end
 
-      def to_h
-        {
-          level: @level,
-          dictionary_size: @dictionary_size,
-          num_fast_bytes: @num_fast_bytes,
-          match_finder: @match_finder,
-          num_threads: @num_threads,
-          solid: @solid,
-          buffer_size: @buffer_size,
-        }.compact
-      end
-
-      # Serialize to JSON
+      # Apply a hash of attributes. Only keys declared as +attribute+s
+      # above are applied; unknown keys are silently ignored.
       #
-      # @return [String] JSON representation
-      def to_json(*args)
-        to_h.to_json(*args)
+      # @param attributes [Hash{Symbol=>Object}]
+      # @return [self]
+      def apply(attributes)
+        self.class.attributes.each do |attr|
+          name = attr.name
+          public_send("#{name}=", attributes[name]) if attributes.key?(name)
+        end
+        self
       end
 
-      # Deserialize from JSON
+      # Validate that all set values are within their type's domain.
       #
-      # @param json [String] JSON string
-      # @return [CompressionOptions] Deserialized instance
-      def self.from_json(json)
-        data = JSON.parse(json)
-        new(**data.transform_keys(&:to_sym))
+      # @raise [ArgumentError] if any value is invalid
+      # @return [Boolean] true if valid
+      def validate!
+        raise ArgumentError, "level must be 0-9" unless (0..9).cover?(level)
+
+        true
       end
     end
   end

data/lib/omnizip/models/conversion_options.rb

@@ -2,22 +2,18 @@
 
 module Omnizip
   module Models
-    # Model for format conversion options
+    # Options for converting between archive formats.
+    #
+    # Plain Ruby value object. (Track 13 of TODO.refactor recommends
+    # migrating this to lutaml-model once symbol-typed attributes are
+    # available.)
     class ConversionOptions
+      VALID_FORMATS = %i[zip seven_zip 7z].freeze
+
       attr_accessor :source_format, :target_format, :compression,
                     :compression_level, :filter, :preserve_metadata,
                     :temp_directory, :solid, :delete_source
 
-      # Initialize conversion options
-      # @param source_format [Symbol, nil] Source format (auto-detect if nil)
-      # @param target_format [Symbol] Target format
-      # @param compression [Symbol, nil] Compression algorithm
-      # @param compression_level [Integer] Compression level (1-9)
-      # @param filter [Symbol, nil] Filter to apply
-      # @param preserve_metadata [Boolean] Preserve metadata
-      # @param temp_directory [String, nil] Temporary directory
-      # @param solid [Boolean] Use solid compression (7z only)
-      # @param delete_source [Boolean] Delete source after conversion
       def initialize(
         source_format: nil,
         target_format: :seven_zip,
@@ -40,8 +36,6 @@ module Omnizip
         @delete_source = delete_source
       end
 
-      # Convert to hash
-      # @return [Hash] Options as hash
       def to_h
         {
           source_format: source_format,
@@ -56,8 +50,6 @@ module Omnizip
         }
       end
 
-      # Validate options
-      # @raise [ArgumentError] If options are invalid
       def validate
         validate_format(target_format, "target")
         validate_format(source_format, "source") if source_format
@@ -69,11 +61,10 @@ module Omnizip
       private
 
       def validate_format(format, type)
-        valid_formats = %i[zip seven_zip 7z]
-        return if valid_formats.include?(format)
+        return if VALID_FORMATS.include?(format)
 
         raise ArgumentError, "Invalid #{type} format: #{format}. " \
-                             "Valid formats: #{valid_formats.join(', ')}"
+                             "Valid formats: #{VALID_FORMATS.join(', ')}"
       end
 
       def validate_compression_level

data/lib/omnizip/models/parallel_options.rb

@@ -60,6 +60,31 @@ module Omnizip
         true
       end
 
+      # Apply a hash of attributes to this options object. Only keys
+      # that correspond to known writers (+threads=+, +queue_size=+,
+      # etc.) are applied; unknown keys are silently ignored.
+      #
+      # @param attributes [Hash{Symbol=>Object}] attributes to set
+      # @return [self]
+      def apply(attributes)
+        SETTERS.each do |key, setter|
+          next unless attributes.key?(key)
+
+          public_send(setter, attributes[key])
+        end
+        self
+      end
+
+      SETTERS = {
+        threads: :threads=,
+        queue_size: :queue_size=,
+        chunk_size: :chunk_size=,
+        strategy: :strategy=,
+        verbose: :verbose=,
+        batch_size: :batch_size=,
+      }.freeze
+      private_constant :SETTERS
+
       # Create a copy of options
       #
       # @return [ParallelOptions] new instance with same values

data/lib/omnizip/optimization_registry.rb

@@ -1,59 +1,25 @@
 # frozen_string_literal: true
 
 module Omnizip
-  # Registry for performance optimization strategies using the Registry pattern
-  class OptimizationRegistry
+  class OptimizationRegistry < Omnizip::Registry
     class << self
-      # Register an optimization strategy
-      def register(name, strategy_class)
-        strategies[name] = strategy_class
+      def not_found_error_class
+        Omnizip::OptimizationNotFoundError
       end
 
-      # Get an optimization strategy by name
-      def get(name)
-        strategies[name] || raise(
-          Omnizip::OptimizationNotFound,
-          "Optimization strategy not found: #{name}",
-        )
+      def label
+        "Optimization strategy"
       end
 
-      # Check if an optimization strategy is registered
-      def registered?(name)
-        strategies.key?(name)
-      end
-
-      # List all registered optimization strategies
-      def all
-        strategies.keys
-      end
-
-      # Get all optimization strategies as a hash
-      def strategies
-        @strategies ||= {}
-      end
-
-      # Clear all registered strategies (useful for testing)
-      def clear!
-        @strategies = {}
-      end
-
-      # Apply an optimization strategy to a target
       def apply(name, target, **options)
-        strategy_class = get(name)
-        strategy = strategy_class.new(**options)
-        strategy.optimize(target)
+        get(name).new(**options).optimize(target)
       end
 
-      # Get optimization metadata
       def metadata(name)
-        strategy_class = get(name)
-        return {} unless strategy_class.respond_to?(:metadata)
-
-        strategy_class.metadata
+        get(name).metadata
       end
     end
 
-    # Base class for optimization strategies
     class Strategy
       attr_reader :options
 
@@ -61,13 +27,11 @@ module Omnizip
         @options = options
       end
 
-      # Override in subclasses to implement optimization logic
-      def optimize(target)
+      def optimize(_target)
         raise NotImplementedError,
               "#{self.class} must implement #optimize"
       end
 
-      # Override in subclasses to provide strategy metadata
       def self.metadata
         {
           name: name,