omnizip 0.4.7-arm-linux

data/lib/omnizip/metadata/metadata_validator.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Metadata
+    # Validates metadata changes before applying
+    class MetadataValidator
+      # Validate entry metadata
+      # @param metadata [EntryMetadata] Metadata to validate
+      # @raise [ArgumentError] If metadata is invalid
+      def validate_entry(metadata)
+        validate_comment(metadata.comment) if metadata.comment
+        # validate_entry is public API.
+        # allowed: metadata need only expose what it validates
+        validate_time(metadata.mtime) if metadata.respond_to?(:mtime)
+        validate_permissions(metadata.unix_permissions) if metadata.unix_permissions
+
+        true
+      end
+
+      # Validate archive metadata
+      # @param metadata [ArchiveMetadata] Metadata to validate
+      # @raise [ArgumentError] If metadata is invalid
+      def validate_archive(metadata)
+        validate_comment(metadata.comment) if metadata.comment
+
+        true
+      end
+
+      # Validate comment length
+      # @param comment [String] Comment to validate
+      # @raise [ArgumentError] If comment is too long
+      def validate_comment(comment)
+        max_length = 65_535 # ZIP format limit
+        return true if comment.bytesize <= max_length
+
+        raise ArgumentError,
+              "Comment too long: #{comment.bytesize} bytes (max: #{max_length})"
+      end
+
+      # Validate time value
+      # @param time [Time] Time to validate
+      # @raise [ArgumentError] If time is invalid
+      def validate_time(time)
+        return true unless time
+
+        unless time.is_a?(Time)
+          raise ArgumentError, "Time must be a Time object, got #{time.class}"
+        end
+
+        # DOS time range: 1980-01-01 to 2107-12-31
+        min_time = Time.new(1980, 1, 1)
+        max_time = Time.new(2107, 12, 31, 23, 59, 59)
+
+        if time < min_time || time > max_time
+          raise ArgumentError, "Time out of DOS range (1980-2107): #{time}"
+        end
+
+        true
+      end
+
+      # Validate Unix permissions
+      # @param perms [Integer] Permissions to validate
+      # @raise [ArgumentError] If permissions are invalid
+      def validate_permissions(perms)
+        return true unless perms
+
+        unless perms.is_a?(Integer)
+          raise ArgumentError,
+                "Permissions must be an integer, got #{perms.class}"
+        end
+
+        unless (0..0o777).cover?(perms)
+          raise ArgumentError,
+                "Permissions out of range: 0#{perms.to_s(8)} (max: 0777)"
+        end
+
+        true
+      end
+
+      # Validate filename
+      # @param filename [String] Filename to validate
+      # @raise [ArgumentError] If filename is invalid
+      def validate_filename(filename)
+        return true unless filename
+
+        max_length = 65_535 # ZIP format limit
+        if filename.bytesize > max_length
+          raise ArgumentError,
+                "Filename too long: #{filename.bytesize} bytes (max: #{max_length})"
+        end
+
+        # Check for invalid characters
+        if filename.include?("\x00")
+          raise ArgumentError, "Filename contains null character"
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/omnizip/metadata.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Metadata editing module
+  # Provides in-place metadata modification without recompression
+  module Metadata
+    # Nested classes - autoloaded
+    autoload :EntryMetadata, "omnizip/metadata/entry_metadata"
+    autoload :ArchiveMetadata, "omnizip/metadata/archive_metadata"
+    autoload :MetadataValidator, "omnizip/metadata/metadata_validator"
+    autoload :MetadataRegistry, "omnizip/metadata/metadata_registry"
+    autoload :MetadataEditor, "omnizip/metadata/metadata_editor"
+
+    class << self
+      # Edit entry metadata
+      # @param entry [Omnizip::Zip::Entry] Entry to edit
+      # @yield [metadata] Block to modify metadata
+      # @return [EntryMetadata] Entry metadata object
+      def edit_entry(entry, &block)
+        metadata = EntryMetadata.new(entry)
+        yield(metadata) if block
+        metadata
+      end
+
+      # Edit archive metadata
+      # @param archive [Omnizip::Zip::File] Archive to edit
+      # @yield [metadata] Block to modify metadata
+      # @return [ArchiveMetadata] Archive metadata object
+      def edit_archive(archive, &block)
+        metadata = ArchiveMetadata.new(archive)
+        yield(metadata) if block
+        metadata
+      end
+
+      # Create a metadata editor for batch operations
+      # @param archive [Omnizip::Zip::File] Archive to edit
+      # @return [MetadataEditor] Metadata editor
+      def editor(archive)
+        MetadataEditor.new(archive)
+      end
+
+      # Validate metadata
+      # @param metadata [EntryMetadata, ArchiveMetadata] Metadata to validate
+      # @return [Boolean] True if valid
+      def validate(metadata)
+        validator = MetadataValidator.new
+        case metadata
+        when EntryMetadata
+          validator.validate_entry(metadata)
+        when ArchiveMetadata
+          validator.validate_archive(metadata)
+        else
+          raise ArgumentError, "Unknown metadata type: #{metadata.class}"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/models/algorithm_metadata.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Metadata describing a compression algorithm.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    class AlgorithmMetadata < Lutaml::Model::Serializable
+      include AttributeApply
+
+      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
+
+      # Apply a hash of attributes (whitelisted to declared attributes).
+      #
+      # @param attributes [Hash{Symbol=>Object}]
+      # @return [self]
+    end
+  end
+end

data/lib/omnizip/models/attribute_apply.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# Copyright (C) 2025 Ribose Inc.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a
+# copy of this software and associated documentation files (the "Software"),
+# to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Software, and to permit persons to whom the
+# Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+# DEALINGS IN THE SOFTWARE.
+
+module Omnizip
+  module Models
+    # Shared #apply for lutaml-model Serializables: set every declared
+    # attribute present in the hash. Unknown and String keys are
+    # ignored (String keys so +to_hash+ output needs +.symbolize_keys+
+    # first — +.from_hash+ handles the round trip).
+    module AttributeApply
+      # @param attributes [Hash{Symbol=>Object}]
+      # @return [self]
+      def apply(attributes)
+        self.class.attributes.each_key do |name|
+          public_send("#{name}=", attributes[name]) if attributes.key?(name)
+        end
+        self
+      end
+    end
+  end
+end

data/lib/omnizip/models/compression_options.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "json"
+
+module Omnizip
+  module Models
+    # Model representing compression operation options.
+    #
+    # 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
+      include AttributeApply
+
+      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
+
+      # Apply a hash of attributes. Only keys declared as +attribute+s
+      # above are applied; unknown keys are silently ignored.
+      #
+      # @param attributes [Hash{Symbol=>Object}]
+      # @return [self]
+
+      # Validate that all set values are within their type's domain.
+      #
+      # @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
+end

data/lib/omnizip/models/conversion_options.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Options for converting between archive formats.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    class ConversionOptions < Lutaml::Model::Serializable
+      VALID_FORMATS = %i[zip seven_zip 7z].freeze
+
+      attribute :source_format, :symbol
+      attribute :target_format, :symbol, default: :seven_zip
+      attribute :compression, :symbol
+      attribute :compression_level, :integer, default: 5
+      attribute :filter, :symbol
+      attribute :preserve_metadata, :boolean, default: true
+      attribute :temp_directory, :string
+      attribute :solid, :boolean, default: true
+      attribute :delete_source, :boolean, default: false
+
+      # Both flags on every field: render_default alone still drops a key that
+      # was explicitly assigned nil, and Converter builds this object with
+      # new(**options) straight from caller-supplied hashes.
+      key_value do
+        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 "compression", to: :compression,
+                           render_default: true, render_nil: true
+        map "compression_level", to: :compression_level,
+                                 render_default: true, render_nil: true
+        map "filter", to: :filter,
+                      render_default: true, render_nil: true
+        map "preserve_metadata", to: :preserve_metadata,
+                                 render_default: true, render_nil: true
+        map "temp_directory", to: :temp_directory,
+                              render_default: true, render_nil: true
+        map "solid", to: :solid,
+                     render_default: true, render_nil: true
+        map "delete_source", to: :delete_source,
+                             render_default: true, render_nil: true
+      end
+
+      # Validate that formats and compression level are in range.
+      #
+      # Named +validate_options!+ rather than +validate+ so it does not
+      # shadow Lutaml::Model::Validation#validate(register:).
+      #
+      # @raise [ArgumentError] if any value is invalid
+      # @return [Boolean] true if valid
+      def validate_options!
+        validate_format(target_format, "target")
+        validate_format(source_format, "source") if source_format
+        validate_compression_level
+
+        true
+      end
+
+      private
+
+      def validate_format(format, type)
+        return if VALID_FORMATS.include?(format)
+
+        raise ArgumentError, "Invalid #{type} format: #{format}. " \
+                             "Valid formats: #{VALID_FORMATS.join(', ')}"
+      end
+
+      def validate_compression_level
+        return if (1..9).cover?(compression_level)
+
+        raise ArgumentError,
+              "Invalid compression level: #{compression_level}. Must be 1-9"
+      end
+    end
+  end
+end

data/lib/omnizip/models/conversion_result.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # 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.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.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.to_f.zero? || source_size.to_i.zero?
+
+        speed = source_size / duration / 1_048_576.0
+        rounded = speed.round(2)
+        # Return actual speed if rounding would give 0 but speed is positive
+        rounded.zero? && speed.positive? ? speed : rounded
+      end
+
+      # 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 " \
+          "#{target_path} (#{format_size(target_size)}) in #{duration.round(2)}s. " \
+          "#{size_reduction.positive? ? "Saved #{size_reduction.to_i}%" : "Increased #{(-size_reduction).to_i}%"}"
+      end
+
+      private
+
+      def format_size(bytes)
+        Omnizip::CliOutputFormatter.format_size(bytes)
+      end
+    end
+  end
+end

data/lib/omnizip/models/eta_result.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+#
+# Copyright (C) 2025 Ribose Inc.
+#
+
+require "lutaml/model"
+
+module Omnizip
+  module Models
+    # Model representing an ETA (Estimated Time to Arrival) calculation result.
+    #
+    # This class encapsulates the result of ETA calculations, including
+    # seconds remaining, formatted time string, and confidence interval.
+    #
+    # Serialized via lutaml-model — no hand-rolled +to_h+ / +to_json+.
+    class ETAResult < Lutaml::Model::Serializable
+      # No mapping block: the default mapping already omits unassigned
+      # attributes, which is what the previous +to_h+ did with +.compact+.
+      attribute :seconds_remaining, :float
+      attribute :formatted, :string
+      attribute :confidence_lower, :float
+      attribute :confidence_upper, :float
+
+      # Get confidence interval as array
+      #
+      # @return [Array<Float>] [lower, upper] bounds in seconds
+      def confidence_interval
+        [confidence_lower, confidence_upper]
+      end
+
+      # Check if ETA is reliable (confidence interval is reasonable)
+      #
+      # @return [Boolean] true if confidence interval is within 50% of estimate
+      def reliable?
+        unless seconds_remaining && confidence_lower && confidence_upper
+          return false
+        end
+
+        range = confidence_upper - confidence_lower
+        range < (seconds_remaining * 0.5)
+      end
+    end
+  end
+end

data/lib/omnizip/models/extraction_rule.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Models
+    # Represents a rule for extracting files from an archive
+    #
+    # Defines what files to extract and how to extract them using
+    # patterns, predicates, and options.
+    class ExtractionRule
+      attr_reader :patterns, :predicates, :options
+
+      # Initialize a new extraction rule
+      #
+      # @param patterns [Array<String, Regexp>] Patterns to match
+      # @param predicates [Array<Proc>] Custom predicates for matching
+      # @param options [Hash] Extraction options
+      # @option options [Boolean] :preserve_paths Keep directory structure
+      # @option options [Boolean] :flatten Extract all to destination root
+      # @option options [Boolean] :overwrite Overwrite existing files
+      # @option options [String] :dest_prefix Prefix for destination paths
+      def initialize(patterns: [], predicates: [], options: {})
+        @patterns = Array(patterns)
+        @predicates = Array(predicates)
+        @options = default_options.merge(options)
+      end
+
+      # Add a pattern to the rule
+      #
+      # @param pattern [String, Regexp] Pattern to add
+      # @return [self]
+      def add_pattern(pattern)
+        @patterns << pattern
+        self
+      end
+
+      # Add a predicate to the rule
+      #
+      # @param predicate [Proc] Predicate block to add
+      # @return [self]
+      def add_predicate(&predicate)
+        @predicates << predicate if predicate
+        self
+      end
+
+      # Check if any patterns are defined
+      #
+      # @return [Boolean]
+      def patterns?
+        !@patterns.empty?
+      end
+
+      # Check if any predicates are defined
+      #
+      # @return [Boolean]
+      def predicates?
+        !@predicates.empty?
+      end
+
+      # Check if the rule has any conditions
+      #
+      # @return [Boolean]
+      def conditions?
+        patterns? || predicates?
+      end
+
+      # Get option value
+      #
+      # @param key [Symbol] Option key
+      # @return [Object] Option value
+      def [](key)
+        @options[key]
+      end
+
+      # Set option value
+      #
+      # @param key [Symbol] Option key
+      # @param value [Object] Option value
+      def []=(key, value)
+        @options[key] = value
+      end
+
+      # Check if paths should be preserved
+      #
+      # @return [Boolean]
+      def preserve_paths?
+        @options[:preserve_paths]
+      end
+
+      # Check if paths should be flattened
+      #
+      # @return [Boolean]
+      def flatten?
+        @options[:flatten]
+      end
+
+      # Check if existing files should be overwritten
+      #
+      # @return [Boolean]
+      def overwrite?
+        @options[:overwrite]
+      end
+
+      private
+
+      def default_options
+        {
+          preserve_paths: true,
+          flatten: false,
+          overwrite: false,
+          dest_prefix: nil,
+        }
+      end
+    end
+  end
+end