omnizip 0.3.1

data/lib/omnizip/profile/profile_registry.rb

@@ -0,0 +1,161 @@
+# 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 Naming/BlockForwarding, Style/ArgumentsForwarding -- Ruby 3.0 compatibility
+      def each(&block)
+        all.each(&block)
+      end
+      # rubocop:enable Naming/BlockForwarding, Style/ArgumentsForwarding
+
+      # 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,36 @@
+# frozen_string_literal: true
+
+require_relative "compression_profile"
+require_relative "../file_type/mime_classifier"
+
+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,190 @@
+# frozen_string_literal: true
+
+require_relative "profile/compression_profile"
+require_relative "profile/profile_registry"
+require_relative "profile/profile_detector"
+require_relative "profile/custom_profile"
+require_relative "profile/fast_profile"
+require_relative "profile/balanced_profile"
+require_relative "profile/maximum_profile"
+require_relative "profile/text_profile"
+require_relative "profile/binary_profile"
+require_relative "profile/archive_profile"
+
+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
+    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
+
+      # 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
+
+      # 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)
+        require_relative "file_type/mime_classifier"
+
+        # 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

data/lib/omnizip/profiler/report_generator.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Omnizip
+  class Profiler
+    # Generates formatted profiling reports with optimization recommendations
+    class ReportGenerator
+      attr_reader :report
+
+      def initialize(report)
+        @report = report
+      end
+
+      # Generate a human-readable text report
+      def generate_text_report
+        lines = []
+        lines << ("=" * 80)
+        lines << "PERFORMANCE PROFILING REPORT"
+        lines << ("=" * 80)
+        lines << "Profile: #{report.profile_name}"
+        lines << "Timestamp: #{report.timestamp}"
+        lines << ""
+
+        lines += generate_summary_section
+        lines += generate_results_section
+        lines += generate_hot_paths_section
+        lines += generate_bottlenecks_section
+
+        lines.join("\n")
+      end
+
+      # Generate a JSON report
+      def generate_json_report
+        JSON.pretty_generate(report.to_h)
+      end
+
+      # Save report to file
+      def save_to_file(filename, format: :text)
+        content = case format
+                  when :text then generate_text_report
+                  when :json then generate_json_report
+                  else raise ArgumentError, "Unknown format: #{format}"
+                  end
+
+        # Create parent directories if they don't exist
+        dir = File.dirname(filename)
+        FileUtils.mkdir_p(dir)
+
+        File.write(filename, content)
+        puts "Report saved to #{filename}"
+      end
+
+      # Print report to console
+      def print_report
+        puts generate_text_report
+      end
+
+      private
+
+      def generate_summary_section
+        lines = []
+        lines << ("-" * 80)
+        lines << "SUMMARY"
+        lines << ("-" * 80)
+        lines << format("Total Execution Time: %.3fs",
+                        report.total_execution_time)
+        lines << format("Total Memory Allocated: %s",
+                        format_bytes(report.total_memory_allocated))
+        lines << format("Total GC Runs: %d", report.total_gc_runs)
+        lines << format("Operations Profiled: %d", report.results.size)
+        lines << ""
+        lines
+      end
+
+      def generate_results_section
+        return [] if report.results.empty?
+
+        lines = []
+        lines << ("-" * 80)
+        lines << "DETAILED RESULTS"
+        lines << ("-" * 80)
+        lines << "Operation                                    Time (s)          Memory      Calls"
+        lines << ("-" * 80)
+
+        report.results.sort_by(&:total_time).reverse.each do |result|
+          lines << format("%-40s %12.3f %15s %10d",
+                          truncate(result.operation_name, 40),
+                          result.total_time || 0.0,
+                          format_bytes(result.memory_allocated || 0),
+                          result.call_count || 0)
+        end
+        lines << ""
+        lines
+      end
+
+      def generate_hot_paths_section
+        return [] if report.hot_paths.empty?
+
+        lines = []
+        lines << ("-" * 80)
+        lines << "HOT PATHS (>10% execution time)"
+        lines << ("-" * 80)
+
+        report.hot_paths.each do |hot_path|
+          lines << format("  %s: %.3fs (%.1f%%)",
+                          hot_path[:operation],
+                          hot_path[:time],
+                          hot_path[:percentage])
+        end
+        lines << ""
+        lines
+      end
+
+      def generate_bottlenecks_section
+        return [] if report.bottlenecks.empty?
+
+        lines = []
+        lines << ("-" * 80)
+        lines << "PERFORMANCE BOTTLENECKS"
+        lines << ("-" * 80)
+
+        report.bottlenecks.group_by { |b| b[:type] }.each do |type, bottlenecks|
+          lines << "\n#{type.to_s.upcase} Bottlenecks:"
+          bottlenecks.each do |bottleneck|
+            lines << format("  [%s] %s",
+                            bottleneck[:severity].to_s.upcase,
+                            bottleneck[:operation])
+
+            case type
+            when :memory
+              lines << format("    Memory: %s",
+                              format_bytes(bottleneck[:allocated]))
+            when :cpu
+              lines << format("    Time: %.3fs", bottleneck[:time])
+            when :gc
+              lines << format("    GC Pressure: %.2f runs/s",
+                              bottleneck[:gc_pressure])
+            end
+          end
+        end
+        lines << ""
+        lines
+      end
+
+      def format_bytes(bytes)
+        return "0 B" if bytes.nil? || bytes.zero?
+
+        units = %w[B KB MB GB]
+        size = bytes.to_f
+        unit_index = 0
+
+        while size >= 1024.0 && unit_index < units.size - 1
+          size /= 1024.0
+          unit_index += 1
+        end
+
+        format("%.2f %s", size, units[unit_index])
+      end
+
+      def truncate(string, max_length)
+        return string if string.length <= max_length
+
+        "#{string[0...(max_length - 3)]}..."
+      end
+    end
+  end
+end