omnizip 0.4.7-aarch64-linux

data/lib/omnizip/profile/archive_profile.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Archive compression profile
+    #
+    # For files that are already compressed.
+    # Uses Store (no compression) to avoid wasting CPU time on files
+    # that cannot be compressed further.
+    class ArchiveProfile < CompressionProfile
+      # Initialize archive profile
+      def initialize
+        super(
+          name: :archive,
+          algorithm: :store,
+          level: 0,
+          filter: nil,
+          solid: false,
+          description: "No compression (already compressed files)"
+        )
+      end
+
+      # Check if this profile is suitable for a MIME type
+      #
+      # @param mime_type [String] MIME type string
+      # @return [Boolean] true if MIME type is already compressed
+      def suitable_for?(mime_type)
+        return true unless mime_type
+
+        # Suitable for archives and media files (already compressed)
+        FileType::MimeClassifier.archive?(mime_type) ||
+          FileType::MimeClassifier.media?(mime_type)
+      end
+    end
+  end
+end

data/lib/omnizip/profile/balanced_profile.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Balanced compression profile
+    #
+    # Provides a good balance between compression speed and ratio.
+    # Uses Deflate with level 6 (the default for most use cases).
+    class BalancedProfile < CompressionProfile
+      # Initialize balanced profile
+      def initialize
+        super(
+          name: :balanced,
+          algorithm: :deflate,
+          level: 6,
+          filter: nil,
+          solid: false,
+          description: "Balanced speed/compression (default)"
+        )
+      end
+
+      # Balanced profile is suitable for all MIME types
+      #
+      # @param _mime_type [String] MIME type string
+      # @return [Boolean] Always true
+      def suitable_for?(_mime_type)
+        true
+      end
+    end
+  end
+end

data/lib/omnizip/profile/binary_profile.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Binary compression profile
+    #
+    # Optimized for compressing executable files.
+    # Uses LZMA2 with BCJ filters to improve compression of executables.
+    class BinaryProfile < CompressionProfile
+      # Initialize binary profile
+      def initialize
+        super(
+          name: :binary,
+          algorithm: :lzma2,
+          level: 6,
+          filter: :bcj_x86,
+          solid: false,
+          description: "Optimized for executables"
+        )
+      end
+
+      # Check if this profile is suitable for a MIME type
+      #
+      # @param mime_type [String] MIME type string
+      # @return [Boolean] true if MIME type is executable
+      def suitable_for?(mime_type)
+        return true unless mime_type
+
+        FileType::MimeClassifier.executable?(mime_type)
+      end
+    end
+  end
+end

data/lib/omnizip/profile/compression_profile.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Base class for compression profiles
+    #
+    # A compression profile encapsulates a set of compression settings that
+    # define how files should be compressed. This includes the algorithm,
+    # compression level, filters, and other options.
+    #
+    # @abstract Subclass and override {#suitable_for?} to implement a custom
+    #   profile
+    class CompressionProfile
+      attr_reader :name, :algorithm, :level, :filter, :solid, :description
+
+      # Initialize a new compression profile
+      #
+      # @param name [Symbol] Profile name
+      # @param algorithm [Symbol] Compression algorithm (:deflate, :lzma2,
+      #   :ppmd7, etc.)
+      # @param level [Integer] Compression level (0-9)
+      # @param filter [Symbol, nil] Filter to apply (:bcj_x86, :bcj_arm, etc.)
+      # @param solid [Boolean] Whether to use solid compression
+      # @param description [String] Human-readable description
+      def initialize(
+        name:,
+        algorithm:,
+        level:,
+        filter: nil,
+        solid: false,
+        description: ""
+      )
+        @name = name
+        @algorithm = algorithm
+        @level = level
+        @filter = filter
+        @solid = solid
+        @description = description
+
+        validate!
+        freeze
+      end
+
+      # Apply this profile to compression options
+      #
+      # @param options [Hash] Existing compression options
+      # @return [Hash] Updated compression options
+      def apply_to(options)
+        options = options.dup
+
+        options[:algorithm] = algorithm
+        options[:level] = level
+        options[:filter] = resolve_filter(options[:file_type]) if filter
+        options[:solid] = solid
+
+        options
+      end
+
+      # Check if this profile is suitable for a given MIME type
+      #
+      # @param mime_type [String] MIME type string to check
+      # @return [Boolean] true if this profile is suitable
+      def suitable_for?(_mime_type)
+        # Default implementation - subclasses should override
+        true
+      end
+
+      # Get profile information as a hash
+      #
+      # @return [Hash] Profile properties
+      def to_h
+        {
+          name: name,
+          algorithm: algorithm,
+          level: level,
+          filter: filter,
+          solid: solid,
+          description: description,
+        }
+      end
+
+      # String representation of the profile
+      #
+      # @return [String]
+      def to_s
+        "#{name} - #{description}"
+      end
+
+      # Inspect representation
+      #
+      # @return [String]
+      def inspect
+        "#<#{self.class.name} name=#{name} " \
+          "algorithm=#{algorithm} level=#{level}>"
+      end
+
+      private
+
+      # Validate profile settings
+      #
+      # @raise [ArgumentError] if settings are invalid
+      def validate!
+        validate_name!
+        validate_algorithm!
+        validate_level!
+        validate_filter!
+      end
+
+      # Validate profile name
+      def validate_name!
+        raise ArgumentError, "Profile name is required" if name.nil?
+        return if name.is_a?(Symbol)
+
+        raise ArgumentError, "Profile name must be a Symbol"
+      end
+
+      # Validate algorithm
+      def validate_algorithm!
+        return if algorithm.nil?
+        return if algorithm.is_a?(Symbol)
+
+        raise ArgumentError, "Algorithm must be a Symbol"
+      end
+
+      # Validate compression level
+      def validate_level!
+        return if level.nil?
+        return if level.is_a?(Integer) && level >= 0 && level <= 9
+
+        raise ArgumentError, "Level must be an Integer between 0 and 9"
+      end
+
+      # Validate filter
+      def validate_filter!
+        return if filter.nil?
+        return if filter.is_a?(Symbol)
+
+        raise ArgumentError, "Filter must be a Symbol or nil"
+      end
+
+      # Resolve filter based on MIME type
+      #
+      # @param mime_type [String, nil] MIME type string
+      # @return [Symbol, nil] Resolved filter
+      def resolve_filter(mime_type)
+        return filter unless filter == :auto
+        return nil unless mime_type
+
+        # Auto-select BCJ filter based on MIME type
+        # For executables, default to x86 architecture
+        if FileType::MimeClassifier.executable?(mime_type)
+          :bcj_x86
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/profile/custom_profile.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Custom user-defined compression profile
+    #
+    # Allows users to create custom profiles with specific settings.
+    # Supports builder pattern for fluent API and profile inheritance.
+    class CustomProfile < CompressionProfile
+      # Builder for creating custom profiles
+      class Builder
+        attr_accessor :name, :algorithm, :level, :filter, :solid, :description,
+                      :base_profile
+
+        # Initialize a new builder
+        #
+        # @param name [Symbol] Profile name
+        # @param base_profile [CompressionProfile, nil] Base profile to extend
+        def initialize(name, base_profile = nil)
+          @name = name
+
+          if base_profile
+            # Inherit settings from base profile
+            @algorithm = base_profile.algorithm
+            @level = base_profile.level
+            @filter = base_profile.filter
+            @solid = base_profile.solid
+            @description = base_profile.description
+            @base_profile = base_profile
+          else
+            # Default settings
+            @algorithm = :deflate
+            @level = 6
+            @filter = nil
+            @solid = false
+            @description = ""
+            @base_profile = nil
+          end
+        end
+
+        # Build the custom profile
+        #
+        # @return [CustomProfile] The built profile
+        def build
+          CustomProfile.new(
+            name: name,
+            algorithm: algorithm,
+            level: level,
+            filter: filter,
+            solid: solid,
+            description: description,
+            base_profile: base_profile,
+          )
+        end
+
+        # Validate builder settings
+        #
+        # @raise [ArgumentError] if settings are invalid
+        # @return [Boolean] true if valid
+        def valid?
+          validate_name!
+          validate_algorithm!
+          validate_level!
+          validate_filter!
+          true
+        end
+
+        private
+
+        # Validate profile name
+        def validate_name!
+          raise ArgumentError, "Profile name is required" if name.nil?
+          return if name.is_a?(Symbol)
+
+          raise ArgumentError, "Profile name must be a Symbol"
+        end
+
+        # Validate algorithm
+        def validate_algorithm!
+          return if algorithm.nil?
+          return if algorithm.is_a?(Symbol)
+
+          raise ArgumentError, "Algorithm must be a Symbol"
+        end
+
+        # Validate compression level
+        def validate_level!
+          return if level.nil?
+          return if level.is_a?(Integer) && level >= 0 && level <= 9
+
+          raise ArgumentError, "Level must be an Integer between 0 and 9"
+        end
+
+        # Validate filter
+        def validate_filter!
+          return if filter.nil?
+          return if filter.is_a?(Symbol)
+
+          raise ArgumentError, "Filter must be a Symbol or nil"
+        end
+      end
+
+      attr_reader :base_profile
+
+      # Initialize a custom profile
+      #
+      # @param name [Symbol] Profile name
+      # @param algorithm [Symbol] Compression algorithm
+      # @param level [Integer] Compression level (0-9)
+      # @param filter [Symbol, nil] Filter to apply
+      # @param solid [Boolean] Whether to use solid compression
+      # @param description [String] Human-readable description
+      # @param base_profile [CompressionProfile, nil] Base profile extended
+      def initialize(
+        name:,
+        algorithm:,
+        level:,
+        filter: nil,
+        solid: false,
+        description: "",
+        base_profile: nil
+      )
+        @base_profile = base_profile
+        super(
+          name: name,
+          algorithm: algorithm,
+          level: level,
+          filter: filter,
+          solid: solid,
+          description: description
+        )
+      end
+
+      # Check if this profile is suitable for a file type
+      #
+      # @param file_type [Omnizip::FileType::DetectionResult] File type
+      # @return [Boolean] Delegates to base profile if available
+      def suitable_for?(file_type)
+        return base_profile.suitable_for?(file_type) if base_profile
+
+        # Custom profiles are suitable for all file types by default
+        true
+      end
+
+      # Convert to hash with base profile information
+      #
+      # @return [Hash] Profile properties including base
+      def to_h
+        hash = super
+        hash[:base_profile] = base_profile.name if base_profile
+        hash
+      end
+    end
+  end
+end

data/lib/omnizip/profile/fast_profile.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Fast compression profile
+    #
+    # Optimizes for compression speed over compression ratio.
+    # Uses Deflate with level 1 for minimal CPU usage.
+    class FastProfile < CompressionProfile
+      # Initialize fast profile
+      def initialize
+        super(
+          name: :fast,
+          algorithm: :deflate,
+          level: 1,
+          filter: nil,
+          solid: false,
+          description: "Fast compression, lower ratio"
+        )
+      end
+
+      # Fast profile is suitable for all MIME types
+      #
+      # @param _mime_type [String] MIME type string
+      # @return [Boolean] Always true
+      def suitable_for?(_mime_type)
+        true
+      end
+    end
+  end
+end

data/lib/omnizip/profile/maximum_profile.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Maximum compression profile
+    #
+    # Optimizes for the best compression ratio regardless of time.
+    # Uses LZMA2 with level 9 and solid compression for maximum compression.
+    class MaximumProfile < CompressionProfile
+      # Initialize maximum profile
+      def initialize
+        super(
+          name: :maximum,
+          algorithm: :lzma2,
+          level: 9,
+          filter: :auto,
+          solid: true,
+          description: "Maximum compression, slower"
+        )
+      end
+
+      # Maximum profile is suitable for all MIME types
+      #
+      # @param _mime_type [String] MIME type string
+      # @return [Boolean] Always true
+      def suitable_for?(_mime_type)
+        true
+      end
+    end
+  end
+end

data/lib/omnizip/profile/profile_detector.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Automatic profile detection based on file analysis
+    #
+    # This class analyzes files and recommends optimal compression profiles
+    # based on MIME type detection and user preferences.
+    class ProfileDetector
+      # Initialize a new profile detector
+      #
+      # @param registry [ProfileRegistry] Profile registry to use
+      def initialize(registry = nil)
+        @registry = registry || Profile.registry
+      end
+
+      # Detect the optimal profile for a file
+      #
+      # @param file_path [String] Path to the file
+      # @param options [Hash] Detection options
+      # @option options [Symbol] :fallback Fallback profile if detection fails
+      #   (default: :balanced)
+      # @return [CompressionProfile] Recommended profile
+      def detect(file_path, options = {})
+        fallback = options[:fallback] || :balanced
+
+        # Detect MIME type
+        mime_type = detect_mime_type(file_path)
+
+        # Find suitable profiles
+        suitable = find_suitable_profiles(mime_type)
+
+        # Return most appropriate profile or fallback to balanced
+        select_best_profile(suitable, mime_type) ||
+          @registry.get(fallback) ||
+          @registry.get(:balanced)
+      end
+
+      # Detect MIME type using FileType detector
+      #
+      # @param file_path [String] Path to the file
+      # @return [String, nil] MIME type string or nil
+      def detect_mime_type(file_path)
+        return nil unless File.exist?(file_path)
+
+        Omnizip::FileType.detect(file_path)
+      rescue StandardError
+        nil
+      end
+
+      # Find profiles suitable for a MIME type
+      #
+      # @param mime_type [String, nil] MIME type string
+      # @return [Array<CompressionProfile>] Suitable profiles
+      def find_suitable_profiles(mime_type)
+        return [] unless mime_type
+
+        @registry.suitable_for(mime_type)
+      end
+
+      # Select the best profile from suitable candidates
+      #
+      # @param profiles [Array<CompressionProfile>] Suitable profiles
+      # @param mime_type [String, nil] MIME type string
+      # @return [CompressionProfile, nil] Best profile or nil
+      def select_best_profile(profiles, mime_type)
+        return nil if profiles.empty?
+        return profiles.first if profiles.size == 1
+
+        # Priority order for specific MIME types
+        priority = profile_priority(mime_type)
+
+        # Find first profile in priority order
+        priority.each do |name|
+          profile = profiles.find { |p| p.name == name }
+          return profile if profile
+        end
+
+        # Return first suitable profile if none matched priority
+        profiles.first
+      end
+
+      private
+
+      # Get profile priority based on MIME type
+      #
+      # @param mime_type [String, nil] MIME type string
+      # @return [Array<Symbol>] Priority-ordered profile names
+      def profile_priority(mime_type)
+        return [:balanced] unless mime_type
+
+        # Use MimeClassifier to determine category
+        category = FileType::MimeClassifier.profile_category(mime_type)
+
+        case category
+        when :text
+          %i[text balanced]
+        when :binary
+          %i[binary maximum balanced]
+        when :archive
+          %i[archive fast balanced]
+        else
+          [:balanced]
+        end
+      end
+    end
+  end
+end