omnizip 0.3.51 → 0.3.53

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

@@ -61,7 +61,7 @@ module Omnizip
           # @param password [String, nil] Optional password
           # @raise [RuntimeError] if extraction fails
           def extract(archive_path, output_dir, password: nil)
-            raise "RAR extraction not available" unless available?
+            raise Omnizip::RarNotAvailableError, "RAR extraction not available" unless available?
 
             if gem_available?
               extract_with_gem(archive_path, output_dir, password)
@@ -78,7 +78,7 @@ module Omnizip
           # @return [Array<Hash>] Entry information
           # @raise [RuntimeError] if listing fails
           def list(archive_path)
-            raise "RAR extraction not available" unless available?
+            raise Omnizip::RarNotAvailableError, "RAR extraction not available" unless available?
 
             if gem_available?
               list_with_gem(archive_path)
@@ -97,7 +97,7 @@ module Omnizip
           # @param password [String, nil] Optional password
           def extract_entry(archive_path, entry_name, output_path,
                             password: nil)
-            raise "RAR extraction not available" unless available?
+            raise Omnizip::RarNotAvailableError, "RAR extraction not available" unless available?
 
             if gem_available?
               extract_entry_with_gem(archive_path, entry_name,
@@ -185,7 +185,7 @@ module Omnizip
             require "unrar"
             Unrar.extract(archive_path, output_dir, password: password)
           rescue StandardError => e
-            raise "Gem extraction failed: #{e.message}"
+            raise Omnizip::DecompressionError, "Gem extraction failed: #{e.message}"
           end
 
           # Extract with system command
@@ -193,7 +193,7 @@ module Omnizip
             cmd = build_extract_command(archive_path, output_dir, password)
             return if system(*cmd)
 
-            raise "Command extraction failed: #{archive_path}"
+            raise Omnizip::DecompressionError, "Command extraction failed: #{archive_path}"
           end
 
           # List with unrar gem
@@ -210,13 +210,13 @@ module Omnizip
               }
             end
           rescue StandardError => e
-            raise "Gem listing failed: #{e.message}"
+            raise Omnizip::DecompressionError, "Gem listing failed: #{e.message}"
           end
 
           # List with system command
           def list_with_command(archive_path)
             output = `"#{command_path}" vb "#{archive_path}" 2>&1`
-            raise "Command listing failed" unless $CHILD_STATUS.success?
+            raise Omnizip::DecompressionError, "Command listing failed" unless $CHILD_STATUS.success?
 
             output.split("\n").map do |line|
               { name: line.strip, size: 0, compressed_size: 0,

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

@@ -64,7 +64,7 @@ module Omnizip
         def extract_entry(entry_name, output_path, password: nil)
           ensure_open
           entry = @entries.find { |e| e.name == entry_name }
-          raise "Entry not found: #{entry_name}" unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
 
           # Create directory if needed
           FileUtils.mkdir_p(File.dirname(output_path))
@@ -150,7 +150,7 @@ module Omnizip
         def parse_archive(io)
           # Read and validate header
           @header = Header.read(io)
-          raise "Invalid RAR archive" unless @header.valid?
+          raise Omnizip::InvalidArchiveError, "Invalid RAR archive" unless @header.valid?
 
           # Update archive info
           @archive_info.version = @header.version

data/lib/omnizip/formats/rpm.rb

@@ -301,7 +301,7 @@ module Omnizip
         #
         # @param output_dir [String] Output directory
         def extract(output_dir)
-          raise "RPM not opened" unless @file
+          raise Omnizip::IOError, "RPM not opened" unless @file
 
           FileUtils.mkdir_p(output_dir)
 
@@ -322,7 +322,7 @@ module Omnizip
         #
         # @return [String] Raw compressed payload data
         def raw_payload
-          raise "RPM not opened" unless @file
+          raise Omnizip::IOError, "RPM not opened" unless @file
 
           payload_io = payload
           payload_io.read
@@ -370,7 +370,7 @@ module Omnizip
         end
 
         def payload
-          raise "RPM not opened" unless @file
+          raise Omnizip::IOError, "RPM not opened" unless @file
 
           # Calculate payload offset
           offset = @lead.length
@@ -434,7 +434,7 @@ module Omnizip
 
           output
         rescue StandardError => e
-          raise "Failed to decompress with #{cmd}: #{e.message}"
+          raise Omnizip::DecompressionError, "Failed to decompress with #{cmd}: #{e.message}"
         end
 
         def extract_cpio(source, output_dir)

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

@@ -103,7 +103,7 @@ module Omnizip
           end
 
           entry = @entries.find { |e| e.name == entry_name }
-          raise "Entry not found: #{entry_name}" unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
 
           # Create directory if needed
           FileUtils.mkdir_p(File.dirname(output_path))

data/lib/omnizip/formats/seven_zip/split_archive_reader.rb

@@ -70,7 +70,7 @@ module Omnizip
         # @raise [RuntimeError] if entry not found or extraction fails
         def extract_entry(entry_name, output_path)
           entry = @entries.find { |e| e.name == entry_name }
-          raise "Entry not found: #{entry_name}" unless entry
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
 
           # Create directory if needed
           FileUtils.mkdir_p(File.dirname(output_path))

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

@@ -203,7 +203,7 @@ module Omnizip
           @file.seek(@header.header_size)
           compressed_toc = @file.read(@header.toc_compressed_size)
 
-          raise "Failed to read TOC" unless compressed_toc
+          raise Omnizip::InvalidArchiveError, "Failed to read TOC" unless compressed_toc
 
           # Parse TOC
           @toc = Toc.parse(compressed_toc, @header.toc_uncompressed_size)
@@ -272,7 +272,7 @@ module Omnizip
             inf.close
             result
           rescue Zlib::Error => e
-            raise "Failed to decompress data: #{e.message}"
+            raise Omnizip::DecompressionError, "Failed to decompress data: #{e.message}"
           end
         end
 

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

@@ -151,19 +151,94 @@ dereference_links: false)
           read_entry_data(entry)
         end
 
+        # Stream a single entry's decompressed content in +chunk_size+
+        # chunks, yielding each. STORE copies raw bytes and DEFLATE
+        # feeds an incremental inflater, so memory stays bounded by
+        # the chunk size; methods without an incremental decoder fall
+        # back to the whole-entry read (yielded as one chunk). The
+        # streamed path verifies the entry CRC after the last chunk.
+        #
+        # @param entry_name [String] Name of the entry to stream
+        # @param chunk_size [Integer] Read granularity in bytes
+        # @yield [chunk] Decompressed chunk
+        # @return [void]
+        def read_entry_stream(entry_name, chunk_size: 64 * 1024, &block)
+          ensure_read
+          entry = @entries.find { |e| e.filename == entry_name }
+          raise Errno::ENOENT, "Entry not found: #{entry_name}" unless entry
+          return if entry.directory? || entry.symlink?
+
+          crc = Omnizip::Checksums::Crc32.new
+          streamed =
+            File.open(file_path, "rb") do |io|
+              io.seek(entry_data_offset(io, entry), ::IO::SEEK_SET)
+
+              # Bound reads by the entry payload — what follows it in
+              # the file is the central directory, not entry data
+              remaining = entry.compressed_size
+
+              case entry.compression_method
+              when COMPRESSION_STORE
+                stream_raw(io, chunk_size, crc, remaining, &block)
+              when COMPRESSION_DEFLATE
+                stream_deflate(io, chunk_size, crc, remaining, &block)
+              else
+                yield(read_entry_data(entry))
+                false
+              end
+            end
+
+          return unless streamed
+
+          if crc.finalize != entry.crc32
+            raise Omnizip::ChecksumError,
+                  "CRC mismatch for #{entry.filename}"
+          end
+        end
+
         private
 
+        def stream_raw(io, chunk_size, crc, remaining)
+          while remaining.positive? &&
+              (chunk = io.read([chunk_size, remaining].min))
+            break if chunk.empty?
+
+            remaining -= chunk.bytesize
+            crc.update(chunk)
+            yield chunk
+          end
+          true
+        end
+
+        def stream_deflate(io, chunk_size, crc, remaining, &block)
+          require "zlib"
+          inflater = Zlib::Inflate.new(-Zlib::MAX_WBITS)
+          begin
+            while remaining.positive? &&
+                (chunk = io.read([chunk_size, remaining].min))
+              break if chunk.empty?
+
+              remaining -= chunk.bytesize
+              emit_inflated(inflater.inflate(chunk), crc, &block)
+            end
+            emit_inflated(inflater.finish, crc, &block)
+          ensure
+            inflater.close
+          end
+          true
+        end
+
+        def emit_inflated(out, crc)
+          return if out.nil? || out.empty?
+
+          crc.update(out)
+          yield out
+        end
+
         # Decompress and CRC-verify a single entry's data
         def read_entry_data(entry)
           File.open(file_path, "rb") do |io|
-            io.seek(entry.local_header_offset, ::IO::SEEK_SET)
-
-            fixed_header = io.read(30)
-            _signature, _version, _flags, _method, _time, _date, _crc32,
-            _comp_size, _uncomp_size, filename_length, extra_length = fixed_header.unpack("VvvvvvVVVvv")
-
-            variable_data = io.read(filename_length + extra_length)
-            LocalFileHeader.from_binary(fixed_header + variable_data)
+            io.seek(entry_data_offset(io, entry), ::IO::SEEK_SET)
 
             compressed_data = io.read(entry.compressed_size)
             decompressed_data = decompress_data(
@@ -184,6 +259,19 @@ dereference_links: false)
           end
         end
 
+        # File offset of an entry's compressed payload: the local
+        # header's fixed 30 bytes plus its filename/extra fields.
+        def entry_data_offset(io, entry)
+          io.seek(entry.local_header_offset, ::IO::SEEK_SET)
+
+          fixed_header = io.read(30)
+          _signature, _version, _flags, _method, _time, _date, _crc32,
+          _comp_size, _uncomp_size, filename_length, extra_length = fixed_header.unpack("VvvvvvVVVvv")
+
+          io.read(filename_length + extra_length)
+          io.pos
+        end
+
         # Parse the central directory once, on demand
         def ensure_read
           read if @entries.empty? && @central_directory.empty?

data/lib/omnizip/models/conversion_result.rb

@@ -1,84 +1,111 @@
 # frozen_string_literal: true
 
+require "lutaml/model"
+
 module Omnizip
   module Models
-    # Model for format conversion results
-    class ConversionResult
-      attr_reader :source_path, :target_path, :source_format, :target_format,
-                  :source_size, :target_size, :duration, :entry_count,
-                  :compression_ratio, :warnings
-
-      # Initialize conversion result
-      # @param source_path [String] Source file path
-      # @param target_path [String] Target file path
-      # @param source_format [Symbol] Source format
-      # @param target_format [Symbol] Target format
-      # @param source_size [Integer] Source file size in bytes
-      # @param target_size [Integer] Target file size in bytes
-      # @param duration [Float] Conversion duration in seconds
-      # @param entry_count [Integer] Number of entries converted
-      # @param warnings [Array<String>] Conversion warnings
-      def initialize(
-        source_path:,
-        target_path:,
-        source_format:,
-        target_format:,
-        source_size:,
-        target_size:,
-        duration:,
-        entry_count:,
-        warnings: []
-      )
-        @source_path = source_path
-        @target_path = target_path
-        @source_format = source_format
-        @target_format = target_format
-        @source_size = source_size
-        @target_size = target_size
-        @duration = duration
-        @entry_count = entry_count
-        @warnings = warnings
-        @compression_ratio = calculate_compression_ratio
+    # Model for format conversion results.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    # The percentage/speed keys serialize the derived methods; the
+    # attribute names differ from the keys so the framework's
+    # generated readers do not shadow the methods.
+    class ConversionResult < Lutaml::Model::Serializable
+      attribute :source_path, :string
+      attribute :target_path, :string
+      attribute :source_format, :symbol
+      attribute :target_format, :symbol
+      attribute :source_size, :integer
+      attribute :target_size, :integer
+      attribute :duration, :double
+      attribute :entry_count, :integer
+      attribute :warnings, :string, collection: true, default: []
+
+      attribute :ratio, :double, method: :compression_ratio_value
+      attribute :reduction_pct, :double, method: :size_reduction
+      attribute :ratio_pct, :double, method: :size_ratio
+      attribute :speed, :double, method: :processing_speed
+
+      key_value do
+        map "source_path", to: :source_path,
+                           render_default: true, render_nil: true
+        map "target_path", to: :target_path,
+                           render_default: true, render_nil: true
+        map "source_format", to: :source_format,
+                             render_default: true, render_nil: true
+        map "target_format", to: :target_format,
+                             render_default: true, render_nil: true
+        map "source_size", to: :source_size,
+                           render_default: true, render_nil: true
+        map "target_size", to: :target_size,
+                           render_default: true, render_nil: true
+        map "size_reduction", to: :reduction_pct,
+                              render_default: true, render_nil: true
+        map "size_ratio", to: :ratio_pct,
+                          render_default: true, render_nil: true
+        map "duration", to: :duration,
+                        render_default: true, render_nil: true
+        map "entry_count", to: :entry_count,
+                           render_default: true, render_nil: true
+        map "processing_speed", to: :speed,
+                                render_default: true, render_nil: true
+        map "warnings", to: :warnings,
+                        render_default: true, render_nil: true
+        map "compression_ratio", to: :ratio,
+                                 render_default: true, render_nil: true
+      end
+
+      # lutaml-model 0.8.x does not render empty-string/empty-collection
+      # defaults, so they are assigned explicitly to keep every key
+      # present in the serialized shape.
+      def initialize(attrs = {})
+        super({ warnings: [] }.merge(attrs))
       end
 
       # Get size reduction percentage
+      #
       # @return [Float] Size reduction as percentage
       def size_reduction
-        return 0.0 if source_size.zero?
+        return 0.0 if source_size.to_i.zero?
 
         ((source_size - target_size).to_f / source_size * 100).round(2)
       end
 
       # Get size ratio
+      #
       # @return [Float] Target size as percentage of source size
       def size_ratio
-        return 0.0 if source_size.zero?
+        return 0.0 if source_size.to_i.zero?
 
         (target_size.to_f / source_size * 100).round(2)
       end
 
       # Check if conversion resulted in smaller file
+      #
       # @return [Boolean] True if target is smaller
       def smaller?
         target_size < source_size
       end
 
       # Check if conversion resulted in larger file
+      #
       # @return [Boolean] True if target is larger
       def larger?
         target_size > source_size
       end
 
       # Check if there were warnings
+      #
       # @return [Boolean] True if warnings exist
       def warnings?
         !warnings.empty?
       end
 
       # Get average processing speed
+      #
       # @return [Float] MB/s processing speed
       def processing_speed
-        return 0.0 if duration.zero? || source_size.zero?
+        return 0.0 if duration.to_f.zero? || source_size.to_i.zero?
 
         speed = source_size / duration / 1_048_576.0
         rounded = speed.round(2)
@@ -86,26 +113,17 @@ module Omnizip
         rounded.zero? && speed.positive? ? speed : rounded
       end
 
-      # Convert to hash
-      # @return [Hash] Result as hash
-      def to_h
-        {
-          source_path: source_path,
-          target_path: target_path,
-          source_format: source_format,
-          target_format: target_format,
-          source_size: source_size,
-          target_size: target_size,
-          size_reduction: size_reduction,
-          size_ratio: size_ratio,
-          duration: duration,
-          entry_count: entry_count,
-          processing_speed: processing_speed,
-          warnings: warnings,
-        }
+      # Compression ratio (0.0-1.0 fraction saved by compression)
+      #
+      # @return [Float]
+      def compression_ratio_value
+        return 0.0 if source_size.to_i.zero?
+
+        (1.0 - (target_size.to_f / source_size)).round(4)
       end
 
       # Format as human-readable string
+      #
       # @return [String] Formatted result
       def to_s
         "Converted #{source_path} (#{format_size(source_size)}) to " \
@@ -115,20 +133,8 @@ module Omnizip
 
       private
 
-      def calculate_compression_ratio
-        return 0.0 if source_size.zero?
-
-        (1.0 - (target_size.to_f / source_size)).round(4)
-      end
-
       def format_size(bytes)
-        return "0 B" if bytes.zero?
-
-        units = %w[B KB MB GB TB]
-        exp = (Math.log(bytes) / Math.log(1024)).to_i
-        exp = [exp, units.size - 1].min
-
-        "%.1f %s" % [bytes.to_f / (1024**exp), units[exp]]
+        Omnizip::CliOutputFormatter.format_size(bytes)
       end
     end
   end

data/lib/omnizip/models/filter_config.rb

@@ -16,6 +16,8 @@
 # See the COPYING file for the complete text of the license.
 #
 
+require "lutaml/model"
+
 module Omnizip
   module Models
     # Configuration model for a filter in a compression pipeline.
@@ -23,6 +25,8 @@ module Omnizip
     # This class replaces hash-based filter configuration with a proper
     # model class. It provides format-aware ID resolution and validation.
     #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    #
     # @example Create a BCJ filter configuration
     #   config = FilterConfig.new(name: :bcj_x86, architecture: :x86)
     #   config.id_for_format(:xz)         # => 0x04
@@ -31,42 +35,39 @@ module Omnizip
     # @example Create a Delta filter configuration
     #   config = FilterConfig.new(name: :delta)
     #   config.delta?  # => true
-    class FilterConfig
-      # @return [Symbol] Filter name (:bcj_x86, :delta, etc.)
-      attr_reader :name_sym
-
-      # @return [String] Binary properties data for filter configuration
-      attr_accessor :properties
-
-      # @return [Symbol] Target architecture for BCJ filters
-      attr_accessor :architecture
+    class FilterConfig < Lutaml::Model::Serializable
+      attribute :name, :symbol
+      attribute :properties, :string, default: ""
+      attribute :architecture, :symbol
+
+      key_value do
+        map "name", to: :name, render_default: true, render_nil: true
+        map "properties", to: :properties,
+                          render_default: true, render_nil: true
+        map "architecture", to: :architecture,
+                            render_default: true, render_nil: true
+      end
 
-      # Initialize filter configuration.
+      # Initialize filter configuration. The legacy +name_sym+ key is
+      # accepted as an alias for +name+.
       #
       # @param attributes [Hash] Initialization attributes
       # @option attributes [Symbol] :name Filter name
-      # @option attributes [Symbol] :name_sym Filter name (alternative key)
+      # @option attributes [Symbol] :name_sym Filter name (alias)
       # @option attributes [String] :properties Binary properties data
       # @option attributes [Symbol] :architecture Target architecture
       def initialize(attributes = {})
-        @name_sym = attributes[:name] || attributes[:name_sym]
-        @properties = attributes[:properties] || "".b
-        @architecture = attributes[:architecture]
+        attrs = attributes.dup
+        attrs[:name] ||= attrs.delete(:name_sym)
+        attrs[:properties] ||= "" # empty-string defaults do not render
+        super(attrs)
       end
 
-      # Set filter name.
-      #
-      # @param value [Symbol] Filter name
-      # @return [void]
-      def name=(value)
-        @name_sym = value
-      end
-
-      # Get filter name as symbol.
+      # Get filter name as symbol (legacy alias for #name).
       #
       # @return [Symbol] Filter name
       def name_sym
-        @name_sym
+        name
       end
 
       # Get filter instance from registry.
@@ -74,11 +75,11 @@ module Omnizip
       # @return [Object] Filter instance from FilterRegistry
       # @raise [KeyError] If filter not found in registry
       def filter_instance
-        filter = Omnizip::FilterRegistry.get(@name_sym)
+        filter = Omnizip::FilterRegistry.get(name)
 
         # Handle architecture parameter if needed
-        if @architecture && requires_initialize_kwargs?(filter)
-          filter.new(architecture: @architecture)
+        if architecture && requires_initialize_kwargs?(filter)
+          filter.new(architecture: architecture)
         else
           filter.new
         end
@@ -100,7 +101,7 @@ module Omnizip
           filter.id_for_format(format)
         else
           raise NotImplementedError,
-                "Filter #{@name_sym} doesn't support format-aware IDs. " \
+                "Filter #{name} doesn't support format-aware IDs. " \
                 "Use the newer BCJ filter instead."
         end
       end
@@ -109,14 +110,14 @@ module Omnizip
       #
       # @return [Boolean] True if BCJ filter variant
       def bcj?
-        @name_sym.to_s.start_with?("bcj_")
+        name.to_s.start_with?("bcj_")
       end
 
       # Check if this is a Delta filter.
       #
       # @return [Boolean] True if Delta filter
       def delta?
-        @name_sym == :delta
+        name == :delta
       end
 
       # Validate configuration.
@@ -124,26 +125,15 @@ module Omnizip
       # @return [Boolean] True if valid
       # @raise [ArgumentError] If filter name is nil or not registered
       def validate!
-        raise ArgumentError, "Filter name is required" if @name_sym.nil?
+        raise ArgumentError, "Filter name is required" if name.nil?
 
-        unless Omnizip::FilterRegistry.registered?(@name_sym)
-          raise ArgumentError, "Filter not registered: #{@name_sym}"
+        unless Omnizip::FilterRegistry.registered?(name)
+          raise ArgumentError, "Filter not registered: #{name}"
         end
 
         true
       end
 
-      # Convert to hash representation.
-      #
-      # @return [Hash] Hash representation with :name, :properties, :architecture
-      def to_h
-        {
-          name: @name_sym,
-          properties: @properties,
-          architecture: @architecture,
-        }
-      end
-
       private
 
       # Check if filter class requires keyword arguments for initialize.