omnizip 0.3.52 → 0.3.53

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,12 +133,6 @@ 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)
         Omnizip::CliOutputFormatter.format_size(bytes)
       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.

data/lib/omnizip/models/match_result.rb

@@ -1,24 +1,46 @@
 # frozen_string_literal: true
 
+require "lutaml/model"
+
 module Omnizip
   module Models
-    # Represents the result of pattern matching against archive entries
+    # Represents the result of pattern matching against archive entries.
     #
-    # Contains matched entries with metadata about the matching process.
-    class MatchResult
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    # The serialized "matches" is the match COUNT (not the entry
+    # objects, which are arbitrary caller types); the live entry
+    # collection stays a plain reader.
+    class MatchResult < Lutaml::Model::Serializable
       include Enumerable
 
-      attr_reader :matches, :total_scanned, :pattern
+      attribute :total_scanned, :integer, default: 0
+
+      attribute :pattern_repr, :string, method: :pattern_to_s
+      attribute :match_count, :integer, method: :count
+      attribute :rate, :double, method: :match_rate
+
+      key_value do
+        map "pattern", to: :pattern_repr,
+                       render_default: true, render_nil: true
+        map "matches", to: :match_count,
+                       render_default: true, render_nil: true
+        map "scanned", to: :total_scanned,
+                       render_default: true, render_nil: true
+        map "match_rate", to: :rate,
+                          render_default: true, render_nil: true
+      end
+
+      attr_reader :matches, :pattern
 
       # Initialize a new match result
       #
       # @param pattern [Object] The pattern that was matched
       # @param matches [Array] Array of matched entries
       # @param total_scanned [Integer] Total entries scanned
-      def initialize(pattern, matches: [], total_scanned: 0)
+      def initialize(pattern = nil, matches: [], total_scanned: 0)
+        super(total_scanned: total_scanned)
         @pattern = pattern
         @matches = Array(matches)
-        @total_scanned = total_scanned
       end
 
       # Add a matched entry
@@ -35,7 +57,7 @@ module Omnizip
       # @param count [Integer] Number to increment by
       # @return [self]
       def increment_scanned(count = 1)
-        @total_scanned += count
+        self.total_scanned = total_scanned + count
         self
       end
 
@@ -64,9 +86,9 @@ module Omnizip
       #
       # @return [Float] Match rate between 0.0 and 1.0
       def match_rate
-        return 0.0 if @total_scanned.zero?
+        return 0.0 if total_scanned.zero?
 
-        count.to_f / @total_scanned
+        count.to_f / total_scanned
       end
 
       # Get match percentage
@@ -108,16 +130,11 @@ module Omnizip
         @matches.dup
       end
 
-      # Get summary hash
+      # Serialized pattern representation.
       #
-      # @return [Hash]
-      def to_h
-        {
-          pattern: @pattern.to_s,
-          matches: count,
-          scanned: @total_scanned,
-          match_rate: match_rate,
-        }
+      # @return [String] The pattern as a string
+      def pattern_to_s
+        @pattern.to_s
       end
     end
   end

data/lib/omnizip/models/optimization_suggestion.rb

@@ -1,41 +1,60 @@
 # frozen_string_literal: true
 
+require "lutaml/model"
+
 module Omnizip
   module Models
-    # Represents a performance optimization suggestion based on profiling data
-    class OptimizationSuggestion
+    # Represents a performance optimization suggestion based on
+    # profiling data.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    # The priority_score key serializes the derived #priority_score
+    # method under a distinct attribute name.
+    class OptimizationSuggestion < Lutaml::Model::Serializable
       SEVERITY_LEVELS = %i[low medium high critical].freeze
       CATEGORIES = %i[
         memory cpu hotpath algorithm io gc allocation concurrency
       ].freeze
 
-      attr_reader :title, :description, :severity, :category, :impact_estimate,
-                  :implementation_effort, :related_operations, :code_locations,
-                  :metrics
+      attribute :title, :string
+      attribute :description, :string
+      attribute :severity, :symbol
+      attribute :category, :symbol
+      attribute :impact_estimate, :double
+      attribute :implementation_effort, :double
+      attribute :related_operations, :string, collection: true, default: []
+      attribute :code_locations, :string, collection: true, default: []
+      attribute :metrics, :hash, default: {}
+
+      attribute :priority, :double, method: :priority_score
+
+      key_value do
+        map "title", to: :title, render_default: true, render_nil: true
+        map "description", to: :description,
+                           render_default: true, render_nil: true
+        map "severity", to: :severity, render_default: true, render_nil: true
+        map "category", to: :category, render_default: true, render_nil: true
+        map "impact_estimate", to: :impact_estimate,
+                               render_default: true, render_nil: true
+        map "implementation_effort", to: :implementation_effort,
+                                     render_default: true, render_nil: true
+        map "priority_score", to: :priority,
+                              render_default: true, render_nil: true
+        map "related_operations", to: :related_operations,
+                                  render_default: true, render_nil: true
+        map "code_locations", to: :code_locations,
+                              render_default: true, render_nil: true
+        map "metrics", to: :metrics, render_default: true, render_nil: true
+      end
 
-      def initialize(
-        title:,
-        description:,
-        severity:,
-        category:,
-        impact_estimate: nil,
-        implementation_effort: nil,
-        related_operations: [],
-        code_locations: [],
-        metrics: {}
-      )
+      # Severity and category are validated after the framework
+      # constructor assigns the attributes. Empty-collection defaults
+      # are assigned explicitly (lutaml-model 0.8.x drops them).
+      def initialize(attrs = {})
+        super({ related_operations: [], code_locations: [],
+                metrics: {} }.merge(attrs))
         validate_severity!(severity)
         validate_category!(category)
-
-        @title = title
-        @description = description
-        @severity = severity
-        @category = category
-        @impact_estimate = impact_estimate
-        @implementation_effort = implementation_effort
-        @related_operations = related_operations
-        @code_locations = code_locations
-        @metrics = metrics
       end
 
       def critical?
@@ -54,21 +73,6 @@ module Omnizip
         severity_weight * impact_weight * effort_weight
       end
 
-      def to_h
-        {
-          title: title,
-          description: description,
-          severity: severity,
-          category: category,
-          impact_estimate: impact_estimate,
-          implementation_effort: implementation_effort,
-          priority_score: priority_score,
-          related_operations: related_operations,
-          code_locations: code_locations,
-          metrics: metrics,
-        }
-      end
-
       private
 
       def validate_severity!(severity)

data/lib/omnizip/models/performance_result.rb

@@ -1,35 +1,60 @@
-# frozen_string_literal: true
+# frozen_string: true
+
+require "lutaml/model"
 
 module Omnizip
   module Models
-    # Represents the performance characteristics of a profiled operation
-    class PerformanceResult
-      attr_reader :operation_name, :total_time, :cpu_time, :wall_time,
-                  :memory_allocated, :memory_retained, :object_allocations,
-                  :gc_runs, :call_count, :timestamp
+    # Represents the performance characteristics of a profiled operation.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    # The derived-rate keys serialize the calculation methods; attribute
+    # names differ from the keys so generated readers do not shadow them.
+    class PerformanceResult < Lutaml::Model::Serializable
+      attribute :operation_name, :string
+      attribute :total_time, :double
+      attribute :cpu_time, :double
+      attribute :wall_time, :double
+      attribute :memory_allocated, :integer
+      attribute :memory_retained, :integer
+      attribute :object_allocations, :integer
+      attribute :gc_runs, :integer
+      attribute :call_count, :integer
+      attribute :timestamp, :date_time, default: -> { Time.now }
+
+      attribute :throughput, :double, method: :throughput_ops_per_second
+      attribute :average_time, :double, method: :average_time_per_operation
+      attribute :memory_per_op, :double, method: :memory_per_operation
+      attribute :pressure, :double, method: :gc_pressure
 
-      def initialize(
-        operation_name:,
-        total_time: nil,
-        cpu_time: nil,
-        wall_time: nil,
-        memory_allocated: nil,
-        memory_retained: nil,
-        object_allocations: nil,
-        gc_runs: nil,
-        call_count: nil,
-        timestamp: Time.now
-      )
-        @operation_name = operation_name
-        @total_time = total_time
-        @cpu_time = cpu_time
-        @wall_time = wall_time
-        @memory_allocated = memory_allocated
-        @memory_retained = memory_retained
-        @object_allocations = object_allocations
-        @gc_runs = gc_runs
-        @call_count = call_count
-        @timestamp = timestamp
+      key_value do
+        map "operation_name", to: :operation_name,
+                              render_default: true, render_nil: true
+        map "total_time", to: :total_time,
+                          render_default: true, render_nil: true
+        map "cpu_time", to: :cpu_time,
+                        render_default: true, render_nil: true
+        map "wall_time", to: :wall_time,
+                         render_default: true, render_nil: true
+        map "memory_allocated", to: :memory_allocated,
+                                render_default: true, render_nil: true
+        map "memory_retained", to: :memory_retained,
+                               render_default: true, render_nil: true
+        map "object_allocations", to: :object_allocations,
+                                  render_default: true, render_nil: true
+        map "gc_runs", to: :gc_runs,
+                       render_default: true, render_nil: true
+        map "call_count", to: :call_count,
+                          render_default: true, render_nil: true
+        map "throughput_ops_per_second", to: :throughput,
+                                         render_default: true, render_nil: true
+        map "average_time_per_operation", to: :average_time,
+                                          render_default: true, render_nil: true
+        map "memory_per_operation", to: :memory_per_op,
+                                    render_default: true, render_nil: true
+        map "gc_pressure", to: :pressure,
+                           render_default: true, render_nil: true
+        map "timestamp", to: :timestamp,
+                         render_default: true, render_nil: true
       end
 
       def throughput_ops_per_second
@@ -55,25 +80,6 @@ module Omnizip
 
         gc_runs.to_f / total_time
       end
-
-      def to_h
-        {
-          operation_name: operation_name,
-          total_time: total_time,
-          cpu_time: cpu_time,
-          wall_time: wall_time,
-          memory_allocated: memory_allocated,
-          memory_retained: memory_retained,
-          object_allocations: object_allocations,
-          gc_runs: gc_runs,
-          call_count: call_count,
-          throughput_ops_per_second: throughput_ops_per_second,
-          average_time_per_operation: average_time_per_operation,
-          memory_per_operation: memory_per_operation,
-          gc_pressure: gc_pressure,
-          timestamp: timestamp.iso8601,
-        }
-      end
     end
   end
 end