omnizip 0.4.7-x86_64-linux

data/lib/omnizip/profile/profile_registry.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Thread-safe registry for compression profiles
+    #
+    # This class manages both built-in and custom compression profiles,
+    # providing a central location for profile registration, lookup, and
+    # management.
+    class ProfileRegistry
+      # Initialize a new profile registry
+      def initialize
+        @profiles = {}
+        @mutex = Mutex.new
+      end
+
+      # Register a profile
+      #
+      # @param profile [CompressionProfile] Profile to register
+      # @raise [ArgumentError] if profile with same name already exists
+      # @return [CompressionProfile] The registered profile
+      def register(profile)
+        unless profile.is_a?(CompressionProfile)
+          raise ArgumentError,
+                "Profile must be a CompressionProfile instance"
+        end
+
+        @mutex.synchronize do
+          if @profiles.key?(profile.name)
+            raise ArgumentError,
+                  "Profile '#{profile.name}' is already registered"
+          end
+
+          @profiles[profile.name] = profile
+        end
+
+        profile
+      end
+
+      # Register a profile, replacing if it exists
+      #
+      # @param profile [CompressionProfile] Profile to register
+      # @return [CompressionProfile] The registered profile
+      def register!(profile)
+        unless profile.is_a?(CompressionProfile)
+          raise ArgumentError,
+                "Profile must be a CompressionProfile instance"
+        end
+
+        @mutex.synchronize do
+          @profiles[profile.name] = profile
+        end
+
+        profile
+      end
+
+      # Unregister a profile by name
+      #
+      # @param name [Symbol] Profile name
+      # @return [CompressionProfile, nil] The unregistered profile or nil
+      def unregister(name)
+        @mutex.synchronize do
+          @profiles.delete(name)
+        end
+      end
+
+      # Get a profile by name
+      #
+      # @param name [Symbol] Profile name
+      # @return [CompressionProfile, nil] Profile or nil if not found
+      def get(name)
+        @mutex.synchronize do
+          @profiles[name]
+        end
+      end
+
+      # Check if a profile is registered
+      #
+      # @param name [Symbol] Profile name
+      # @return [Boolean] true if profile exists
+      def registered?(name)
+        @mutex.synchronize do
+          @profiles.key?(name)
+        end
+      end
+
+      # Get all registered profile names
+      #
+      # @return [Array<Symbol>] List of profile names
+      def names
+        @mutex.synchronize do
+          @profiles.keys
+        end
+      end
+
+      # Get all registered profiles
+      #
+      # @return [Array<CompressionProfile>] List of profiles
+      def all
+        @mutex.synchronize do
+          @profiles.values
+        end
+      end
+
+      # Find profiles suitable for a MIME type
+      #
+      # @param mime_type [String] MIME type string
+      # @return [Array<CompressionProfile>] Suitable profiles
+      def suitable_for(mime_type)
+        all.select { |profile| profile.suitable_for?(mime_type) }
+      end
+
+      # Clear all registered profiles
+      #
+      # @return [void]
+      def clear
+        @mutex.synchronize do
+          @profiles.clear
+        end
+      end
+
+      # Get the number of registered profiles
+      #
+      # @return [Integer] Profile count
+      def count
+        @mutex.synchronize do
+          @profiles.size
+        end
+      end
+
+      # Iterate over all profiles
+      #
+      # @yield [profile] Yields each profile
+      # @yieldparam profile [CompressionProfile] A registered profile
+      # @return [void]
+      # rubocop:disable-next Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+      def each(&block)
+        all.each(&block)
+      end
+
+      # Get profile information as hash
+      #
+      # @return [Hash{Symbol => Hash}] Profiles indexed by name
+      def to_h
+        @mutex.synchronize do
+          @profiles.transform_values(&:to_h)
+        end
+      end
+
+      # String representation
+      #
+      # @return [String]
+      def inspect
+        @mutex.synchronize do
+          "#<#{self.class.name} profiles=#{@profiles.keys.join(', ')}>"
+        end
+      end
+    end
+  end
+end

data/lib/omnizip/profile/text_profile.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Omnizip
+  module Profile
+    # Text compression profile
+    #
+    # Optimized for compressing text files.
+    # Uses PPMd7 which excels at text compression through context modeling.
+    class TextProfile < CompressionProfile
+      # Initialize text profile
+      def initialize
+        super(
+          name: :text,
+          algorithm: :ppmd7,
+          level: 6,
+          filter: nil,
+          solid: false,
+          description: "Optimized for text 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 text-based
+      def suitable_for?(mime_type)
+        return true unless mime_type
+
+        FileType::MimeClassifier.text?(mime_type)
+      end
+    end
+  end
+end

data/lib/omnizip/profile.rb

@@ -0,0 +1,261 @@
+# frozen_string_literal: true
+
+module Omnizip
+  # Compression profile management
+  #
+  # This module provides a high-level API for working with compression
+  # profiles. Profiles encapsulate compression settings and allow users
+  # to easily select optimal compression strategies for different file types.
+  module Profile
+    # Nested classes - autoloaded
+    autoload :CompressionProfile, "omnizip/profile/compression_profile"
+    autoload :ProfileRegistry, "omnizip/profile/profile_registry"
+    autoload :ProfileDetector, "omnizip/profile/profile_detector"
+    autoload :CustomProfile, "omnizip/profile/custom_profile"
+    autoload :FastProfile, "omnizip/profile/fast_profile"
+    autoload :BalancedProfile, "omnizip/profile/balanced_profile"
+    autoload :MaximumProfile, "omnizip/profile/maximum_profile"
+    autoload :TextProfile, "omnizip/profile/text_profile"
+    autoload :BinaryProfile, "omnizip/profile/binary_profile"
+    autoload :ArchiveProfile, "omnizip/profile/archive_profile"
+
+    class << self
+      # Get the global profile registry
+      #
+      # @return [ProfileRegistry] The global registry
+      def registry
+        @registry ||= ProfileRegistry.new.tap do |reg|
+          register_built_in_profiles(reg)
+        end
+      end
+
+      # Get a profile by name
+      #
+      # @param name [Symbol] Profile name
+      # @return [CompressionProfile, nil] The profile or nil
+      def get(name)
+        registry.get(name)
+      end
+
+      # Define a custom profile
+      #
+      # @param name [Symbol] Profile name
+      # @param base [Symbol, nil] Base profile to extend
+      # @yield [builder] Yields a builder for profile configuration
+      # @yieldparam builder [CustomProfile::Builder] The profile builder
+      # @return [CustomProfile] The created profile
+      #
+      # @example Define a custom profile
+      #   Omnizip::Profile.define(:my_profile) do |p|
+      #     p.algorithm = :lzma2
+      #     p.level = 7
+      #     p.filter = :bcj_x86
+      #     p.solid = true
+      #     p.description = "My custom profile"
+      #   end
+      #
+      # @example Extend an existing profile
+      #   Omnizip::Profile.define(:my_fast, base: :fast) do |p|
+      #     p.level = 2
+      #     p.description = "Slightly better than fast"
+      #   end
+      def define(name, base: nil)
+        base_profile = base ? registry.get(base) : nil
+        builder = CustomProfile::Builder.new(name, base_profile)
+
+        yield builder if block_given?
+
+        builder.valid?
+        profile = builder.build
+
+        registry.register!(profile)
+        profile
+      end
+
+      # List all available profile names
+      #
+      # @return [Array<Symbol>] List of profile names
+      def list
+        registry.names
+      end
+
+      # Get recommended profile for a file type
+      #
+      # @param file_type [String, Symbol] MIME type string or category symbol
+      # @return [CompressionProfile, nil] Recommended profile
+      def for_file_type(file_type)
+        # If file_type is a symbol (category), find first suitable profile
+        return find_profile_for_category(file_type) if file_type.is_a?(Symbol)
+
+        # If file_type is a MIME string, find suitable profiles
+        if file_type.is_a?(String)
+          suitable = registry.suitable_for(file_type)
+          return registry.get(:balanced) if suitable.empty?
+
+          return select_best_profile_for_mime(suitable, file_type)
+        end
+
+        # Default to balanced
+        registry.get(:balanced)
+      end
+
+      # Auto-detect optimal profile for a file
+      #
+      # @param file_path [String] Path to the file
+      # @param options [Hash] Detection options
+      # @return [CompressionProfile] Detected profile
+      def detect(file_path, options = {})
+        detector.detect(file_path, options)
+      end
+
+      # Resolve a profile specification into a concrete profile.
+      # +:auto+ (or "auto") samples +first_file+ through detection and
+      # falls back to +:balanced+ without one; a CompressionProfile
+      # passes through unchanged; anything else names a registered
+      # profile, falling back to +:balanced+ when unknown.
+      #
+      # @param spec [Symbol, String, CompressionProfile] Profile spec
+      # @param first_file [String, nil] Sampling file for :auto
+      # @return [CompressionProfile] Resolved profile
+      def resolve(spec, first_file: nil)
+        case spec
+        when :auto, "auto"
+          first_file ? detect(first_file) : registry.get(:balanced)
+        when CompressionProfile
+          spec
+        else
+          registry.get(spec.to_sym) || registry.get(:balanced)
+        end
+      end
+
+      # Resolve and apply the +:profile+ entry of +options+ into
+      # concrete compression settings. +:auto+ profiles sample the
+      # first readable file at or below +paths+. Returns a new
+      # options hash; +options+ itself is left untouched.
+      #
+      # @param options [Hash] Compression options carrying :profile
+      # @param paths [String, Array<String>] Inputs to sample
+      # @return [Hash] Options with the profile applied and removed
+      def apply(options, paths: [])
+        options = options.dup
+        spec = options.delete(:profile)
+        return options unless spec
+
+        resolve(spec, first_file: first_file_among(paths)).apply_to(options)
+      end
+
+      # The first regular file at or below any of +paths+ — the
+      # sampling target for +:auto+ profiles — or nil when nothing
+      # readable exists.
+      #
+      # @param paths [String, Array<String>] Files or directories
+      # @return [String, nil] Path of the first file found
+      def first_file_among(paths)
+        Array(paths).each do |path|
+          next unless ::File.exist?(path)
+
+          return path if ::File.file?(path)
+
+          if ::File.directory?(path)
+            found = first_file_within(path)
+            return found if found
+          end
+        end
+        nil
+      end
+
+      # Get the profile detector
+      #
+      # @return [ProfileDetector] The detector instance
+      def detector
+        @detector ||= ProfileDetector.new(registry)
+      end
+
+      # Reset the global registry (mainly for testing)
+      #
+      # @return [void]
+      def reset!
+        @registry = nil
+        @detector = nil
+      end
+
+      private
+
+      # Depth-first search for the first regular file under +dir+,
+      # in sorted child order — :auto sampling must not depend on
+      # the OS's directory iteration order.
+      def first_file_within(dir)
+        ::Dir.children(dir).sort.each do |entry|
+          full_path = ::File.join(dir, entry)
+          return full_path if ::File.file?(full_path)
+
+          if ::File.directory?(full_path)
+            found = first_file_within(full_path)
+            return found if found
+          end
+        end
+        nil
+      end
+
+      # Register all built-in profiles
+      #
+      # @param registry [ProfileRegistry] Registry to populate
+      # @return [void]
+      def register_built_in_profiles(registry)
+        registry.register(FastProfile.new)
+        registry.register(BalancedProfile.new)
+        registry.register(MaximumProfile.new)
+        registry.register(TextProfile.new)
+        registry.register(BinaryProfile.new)
+        registry.register(ArchiveProfile.new)
+      end
+
+      # Find profile for a category symbol
+      #
+      # @param category [Symbol] File category
+      # @return [CompressionProfile, nil] Recommended profile
+      def find_profile_for_category(category)
+        case category
+        when :text, :document, :code
+          registry.get(:text)
+        when :executable
+          registry.get(:binary)
+        when :archive, :compressed
+          registry.get(:archive)
+        else
+          registry.get(:balanced)
+        end
+      end
+
+      # Select best profile from suitable candidates based on MIME type
+      #
+      # @param profiles [Array<CompressionProfile>] Suitable profiles
+      # @param mime_type [String] MIME type string
+      # @return [CompressionProfile] Best profile
+      def select_best_profile_for_mime(profiles, mime_type)
+        # Determine category from MIME type
+        category = FileType::MimeClassifier.profile_category(mime_type)
+
+        priority = case category
+                   when :archive
+                     %i[archive fast balanced]
+                   when :text
+                     %i[text balanced]
+                   when :binary
+                     %i[binary maximum balanced]
+                   else
+                     [:balanced]
+                   end
+
+        # Find first profile matching priority
+        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
+    end
+  end
+end

data/lib/omnizip/profiler/memory_profiler.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Omnizip
+  class Profiler
+    # Profiles memory allocation and retention
+    class MemoryProfiler
+      def initialize
+        @call_counts = Hash.new(0)
+      end
+
+      def profile(operation_name)
+        GC.start
+        GC.disable
+
+        gc_stat_before = GC.stat
+        objspace_before = ObjectSpace.count_objects
+
+        yield
+
+        objspace_after = ObjectSpace.count_objects
+        gc_stat_after = GC.stat
+
+        GC.enable
+
+        @call_counts[operation_name] += 1
+
+        # Calculate memory metrics
+        total_allocated = gc_stat_after[:total_allocated_objects] -
+          gc_stat_before[:total_allocated_objects]
+        total_freed = gc_stat_after[:total_freed_objects] -
+          gc_stat_before[:total_freed_objects]
+
+        # Object allocation delta
+        objspace_after[:TOTAL]
+        objspace_before[:TOTAL]
+
+        # Estimate memory based on object allocations
+        # Average Ruby object is ~40 bytes
+        estimated_memory = total_allocated * 40
+
+        Models::PerformanceResult.new(
+          operation_name: operation_name,
+          memory_allocated: estimated_memory,
+          memory_retained: (total_allocated - total_freed) * 40,
+          object_allocations: total_allocated,
+          gc_runs: 0,
+          call_count: @call_counts[operation_name],
+        )
+      ensure
+        GC.enable
+      end
+
+      def reset!
+        @call_counts.clear
+      end
+
+      def call_count(operation_name)
+        @call_counts[operation_name]
+      end
+
+      def total_calls
+        @call_counts.values.sum
+      end
+    end
+  end
+end

data/lib/omnizip/profiler/method_profiler.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "benchmark"
+
+module Omnizip
+  class Profiler
+    # Profiles method execution time and call counts
+    class MethodProfiler
+      def initialize
+        @call_counts = Hash.new(0)
+      end
+
+      def profile(operation_name)
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        gc_stat_before = GC.stat
+
+        yield
+
+        end_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        gc_stat_after = GC.stat
+
+        @call_counts[operation_name] += 1
+
+        wall_time = end_time - start_time
+        gc_runs = gc_stat_after[:count] - gc_stat_before[:count]
+
+        Models::PerformanceResult.new(
+          operation_name: operation_name,
+          total_time: wall_time,
+          wall_time: wall_time,
+          gc_runs: gc_runs,
+          call_count: @call_counts[operation_name],
+        )
+      end
+
+      def reset!
+        @call_counts.clear
+      end
+
+      def call_count(operation_name)
+        @call_counts[operation_name]
+      end
+
+      def total_calls
+        @call_counts.values.sum
+      end
+    end
+  end
+end