snakommit 0.1.1 → 0.1.2

data/lib/snakommit/config.rb

@@ -21,7 +21,7 @@ module Snakommit
         { 'name' => 'perf', 'description' => 'A code change that improves performance' },
         { 'name' => 'test', 'description' => 'Adding missing tests or correcting existing tests' },
         { 'name' => 'build', 'description' => 'Changes that affect the build system or external dependencies' },
-        { 'name' => 'ci', 'description' => 'Changes to our CI configuration files and scripts' },
+        { 'name' => 'ci/cd', 'description' => 'Changes to our CI/CD configuration files and scripts' },
         { 'name' => 'chore', 'description' => 'Other changes that don\'t modify src or test files' }
       ],
       'scopes' => [],
@@ -29,126 +29,98 @@ module Snakommit
       'max_body_line_length' => 72
     }.freeze
 
-    # Initialiser les variables de classe
-    @config_cache = {}
-    @config_last_modified = nil
-
-    # Load configuration from file, creating default if needed
-    # @return [Hash] The configuration hash
-    # @raise [ConfigError] If configuration can't be loaded
-    def self.load
-      create_default_config unless File.exist?(CONFIG_FILE)
-      
-      # Check if config file has been modified since last load
-      current_mtime = File.mtime(CONFIG_FILE) rescue nil
-      
-      # Return cached config if it exists and file hasn't been modified
-      if @config_cache && @config_last_modified == current_mtime
-        return @config_cache.dup
+    class << self
+      # Initialize class variables
+      def setup_cache
+        @config_cache ||= {}
+        @config_last_modified ||= nil
+        true
       end
-      
-      # Load and cache the configuration
-      @config_cache = YAML.load_file(CONFIG_FILE) || {}
-      @config_last_modified = current_mtime
-      
-      # Return a copy to prevent unintentional modifications
-      @config_cache.dup
-    rescue Errno::EACCES, Errno::ENOENT => e
-      raise ConfigError, "Could not load configuration: #{e.message}"
-    rescue => e
-      raise ConfigError, "Unexpected error loading configuration: #{e.message}"
-    end
 
-    # Create the default configuration file
-    # @return [Boolean] True if successful
-    # @raise [ConfigError] If default config can't be created
-    def self.create_default_config
-      # Check if directory exists
-      config_dir = File.dirname(CONFIG_FILE)
-      unless Dir.exist?(config_dir)
-        begin
-          FileUtils.mkdir_p(config_dir)
-        rescue Errno::EACCES => e
-          raise ConfigError, "Permission denied creating config directory: #{e.message}"
-        end
+      def load
+        create_default_config unless File.exist?(CONFIG_FILE)
+        
+        # Use cached config if file hasn't been modified
+        current_mtime = File.mtime(CONFIG_FILE) rescue nil
+        # Ensure cache is initialized
+        setup_cache
+        return @config_cache.dup if @config_cache && @config_last_modified == current_mtime
+        
+        # Load and cache the configuration
+        @config_cache = YAML.load_file(CONFIG_FILE) || {}
+        @config_last_modified = current_mtime
+        
+        @config_cache.dup
+      rescue Errno::EACCES, Errno::ENOENT => e
+        raise ConfigError, "Could not load configuration: #{e.message}"
+      rescue => e
+        raise ConfigError, "Unexpected error loading configuration: #{e.message}"
       end
-      
-      # Write config file if it doesn't exist
-      unless File.exist?(CONFIG_FILE)
-        begin
+
+      def create_default_config
+        # Ensure config directory exists
+        config_dir = File.dirname(CONFIG_FILE)
+        FileUtils.mkdir_p(config_dir) unless Dir.exist?(config_dir)
+        
+        # Write default config if file doesn't exist
+        unless File.exist?(CONFIG_FILE)
           File.write(CONFIG_FILE, DEFAULT_CONFIG.to_yaml)
           
           # Update cache
           @config_cache = DEFAULT_CONFIG.dup
           @config_last_modified = File.mtime(CONFIG_FILE) rescue nil
-        rescue Errno::EACCES => e
-          raise ConfigError, "Permission denied creating config file: #{e.message}"
-        rescue => e
-          raise ConfigError, "Unexpected error creating config file: #{e.message}"
         end
+        
+        true
+      rescue Errno::EACCES => e
+        raise ConfigError, "Permission denied: #{e.message}"
+      rescue => e
+        raise ConfigError, "Failed to create config file: #{e.message}"
       end
       
-      true
-    end
-    
-    # Update configuration values
-    # @param updates [Hash] Configuration values to update
-    # @return [Hash] The updated configuration
-    # @raise [ConfigError] If configuration can't be updated
-    def self.update(updates)
-      config = load
-      config.merge!(updates)
-      
-      # Create a backup of the current configuration
-      backup_config if File.exist?(CONFIG_FILE)
-      
-      # Write the updated configuration
-      File.write(CONFIG_FILE, config.to_yaml)
+      def update(updates)
+        config = load.merge(updates)
+        
+        # Backup and write updated config
+        backup_config if File.exist?(CONFIG_FILE)
+        File.write(CONFIG_FILE, config.to_yaml)
+        
+        # Update cache
+        @config_cache = config.dup
+        @config_last_modified = File.mtime(CONFIG_FILE) rescue nil
+        
+        config
+      rescue => e
+        raise ConfigError, "Failed to update configuration: #{e.message}"
+      end
       
-      # Update cache
-      @config_cache = config.dup
-      @config_last_modified = File.mtime(CONFIG_FILE) rescue nil
+      def get(key, default = nil)
+        load.fetch(key, default)
+      end
       
-      config
-    rescue => e
-      raise ConfigError, "Failed to update configuration: #{e.message}"
-    end
-    
-    # Get a specific configuration value
-    # @param key [String] Configuration key
-    # @param default [Object] Default value if key not found
-    # @return [Object] Configuration value or default
-    def self.get(key, default = nil)
-      config = load
-      config.fetch(key, default)
-    end
-    
-    # Reset configuration to defaults
-    # @return [Hash] The default configuration
-    def self.reset
-      backup_config if File.exist?(CONFIG_FILE)
-      File.write(CONFIG_FILE, DEFAULT_CONFIG.to_yaml)
+      def reset
+        backup_config if File.exist?(CONFIG_FILE)
+        File.write(CONFIG_FILE, DEFAULT_CONFIG.to_yaml)
+        
+        # Update cache
+        @config_cache = DEFAULT_CONFIG.dup
+        @config_last_modified = File.mtime(CONFIG_FILE) rescue nil
+        
+        DEFAULT_CONFIG.dup
+      rescue => e
+        raise ConfigError, "Failed to reset configuration: #{e.message}"
+      end
       
-      # Update cache
-      @config_cache = DEFAULT_CONFIG.dup
-      @config_last_modified = File.mtime(CONFIG_FILE) rescue nil
+      private
       
-      DEFAULT_CONFIG.dup
-    rescue => e
-      raise ConfigError, "Failed to reset configuration: #{e.message}"
-    end
-    
-    private
-    
-    # Backup the current configuration
-    # @return [String] Path to backup file
-    def self.backup_config
-      backup_file = "#{CONFIG_FILE}.bak"
-      FileUtils.cp(CONFIG_FILE, backup_file)
-      backup_file
-    rescue => e
-      warn "Warning: Failed to backup configuration: #{e.message}"
-      nil
-    end
+      def backup_config
+        backup_file = "#{CONFIG_FILE}.bak"
+        FileUtils.cp(CONFIG_FILE, backup_file)
+        backup_file
+      rescue => e
+        warn "Warning: Failed to backup configuration: #{e.message}"
+        nil
+      end
+    end # End of class << self
   end
-end 
+end

data/lib/snakommit/git.rb

@@ -102,7 +102,7 @@ module Snakommit
     # Commit with the given message
     def commit(message)
       with_temp_file(message) do |message_file|
-        stdout, stderr, status = Open3.capture3('git', 'commit', '-F', message_file)
+        _, stderr, status = Open3.capture3('git', 'commit', '-F', message_file)
         
         # Clear any saved selections after successful commit
         clear_saved_selections

data/lib/snakommit/hooks.rb

@@ -205,11 +205,10 @@ module Snakommit
       end
       
       false
-    rescue => e
+    rescue StandardError
       # If we can't read the file, it's not our hook
       false
     end
-
     # Backup an existing hook file
     # @param hook_path [String] Path to the hook file
     # @return [String, nil] Path to the backup file or nil if no backup created
@@ -255,4 +254,4 @@ module Snakommit
       false
     end
   end
-end 
+end

data/lib/snakommit/performance.rb

@@ -7,10 +7,9 @@ module Snakommit
   class Performance
     # Cache for expensive Git operations
     class Cache
-      # Initialize a new cache
-      # @param max_size [Integer] Maximum number of items to cache
-      # @param ttl [Integer] Time-to-live in seconds for cached items
-      def initialize(max_size = 100, ttl = 300) # 5 minutes TTL by default
+      attr_reader :max_size, :ttl
+      
+      def initialize(max_size = 100, ttl = 300)
         @cache = {}
         @max_size = max_size
         @ttl = ttl
@@ -18,9 +17,6 @@ module Snakommit
         @misses = 0
       end
 
-      # Get a value from the cache
-      # @param key [Object] Cache key
-      # @return [Object, nil] Cached value or nil if not found or expired
       def get(key)
         return nil unless @cache.key?(key)
         entry = @cache[key]
@@ -34,10 +30,6 @@ module Snakommit
         entry[:value]
       end
 
-      # Set a value in the cache
-      # @param key [Object] Cache key
-      # @param value [Object] Value to cache
-      # @return [Object] The value that was cached
       def set(key, value)
         cleanup if @cache.size >= @max_size
         @cache[key] = { value: value, timestamp: Time.now }
@@ -45,22 +37,15 @@ module Snakommit
         value
       end
 
-      # Remove a specific key from the cache
-      # @param key [Object] Cache key to invalidate
-      # @return [nil]
       def invalidate(key)
         @cache.delete(key)
         nil
       end
 
-      # Clear the entire cache
-      # @return [Hash] Empty hash
       def clear
         @cache = {}
       end
       
-      # Get cache stats
-      # @return [Hash] Cache statistics
       def stats
         {
           size: @cache.size,
@@ -72,8 +57,6 @@ module Snakommit
         }
       end
       
-      # Calculate cache hit rate
-      # @return [Float] Cache hit rate as a percentage
       def hit_rate
         total = @hits + @misses
         return 0.0 if total.zero?
@@ -82,17 +65,14 @@ module Snakommit
 
       private
 
-      # Clean up expired or oldest entries when cache is full
-      # @return [nil]
       def cleanup
         # Remove expired entries first
-        expired_keys = @cache.select { |_, v| Time.now - v[:timestamp] > @ttl }.keys
-        @cache.delete_if { |k, _| expired_keys.include?(k) }
+        @cache.delete_if { |_, v| Time.now - v[:timestamp] > @ttl }
 
         # If still too large, remove oldest entries
         if @cache.size >= @max_size
           sorted_keys = @cache.sort_by { |_, v| v[:timestamp] }.map(&:first)
-          sorted_keys[0...(@cache.size - @max_size / 2)].each { |k| @cache.delete(k) }
+          sorted_keys.first(@cache.size - @max_size / 2).each { |k| @cache.delete(k) }
         end
         
         nil
@@ -101,25 +81,19 @@ module Snakommit
 
     # Batch processing for Git operations
     class BatchProcessor
-      # Initialize a new batch processor
-      # @param batch_size [Integer] Default batch size for processing
+      attr_reader :batch_size, :total_processed, :batch_count
+      
       def initialize(batch_size = 100)
         @batch_size = batch_size
         @total_processed = 0
         @batch_count = 0
       end
 
-      # Process files in batches
-      # @param files [Array<String>] List of files to process
-      # @param batch_size [Integer, nil] Optional override for batch size
-      # @yield [batch] Yields each batch of files for processing
-      # @yieldparam batch [Array<String>] A batch of files
-      # @return [Array] Combined results from all batches
       def process_files(files, batch_size = nil, &block)
         size = batch_size || @batch_size
         results = []
         
-        files.each_slice(size).each_with_index do |batch, index|
+        files.each_slice(size).each do |batch|
           @batch_count += 1
           batch_result = block.call(batch)
           @total_processed += batch.size
@@ -129,8 +103,6 @@ module Snakommit
         results
       end
       
-      # Get batch processing stats
-      # @return [Hash] Batch processing statistics
       def stats
         {
           batch_size: @batch_size,
@@ -140,8 +112,6 @@ module Snakommit
         }
       end
       
-      # Calculate average batch size
-      # @return [Float] Average batch size
       def average_batch_size
         return 0.0 if @batch_count.zero?
         @total_processed.to_f / @batch_count
@@ -150,10 +120,8 @@ module Snakommit
 
     # Helper for parallel processing where appropriate
     class ParallelHelper
-      # Check if parallel processing is available
-      # @return [Boolean] True if the parallel gem is available
       def self.available?
-        begin
+        @available ||= begin
           require 'parallel'
           true
         rescue LoadError
@@ -161,49 +129,34 @@ module Snakommit
         end
       end
 
-      # Process items in parallel if possible, otherwise sequentially
-      # @param items [Array] Items to process
-      # @param options [Hash] Options for parallel processing
-      # @option options [Integer] :threshold Minimum number of items to use parallel processing
-      # @option options [Integer] :workers Number of workers to use (defaults to processor count)
-      # @yield [item] Block to process each item
-      # @yieldparam item [Object] An item to process
-      # @return [Array] Results of processing all items
       def self.process(items, options = {}, &block)
         threshold = options.delete(:threshold) || 10
         workers = options.delete(:workers) || processor_count
         
         if available? && items.size > threshold
           require 'parallel'
-          Parallel.map(items, { in_processes: workers }.merge(options)) { |item| block.call(item) }
+          Parallel.map(items, { in_processes: workers }.merge(options), &block)
         else
           items.map(&block)
         end
       end
       
-      # Get number of available processors
-      # @return [Integer] Number of processors available
       def self.processor_count
         if defined?(Etc) && Etc.respond_to?(:nprocessors)
           Etc.nprocessors
         else
-          2 # Conservative default
+          2
         end
       end
     end
 
     # Performance monitoring and reporting
     class Monitor
-      # Initialize a new monitor
       def initialize
         @timings = {}
         @counts = {}
       end
 
-      # Measure execution time of a block
-      # @param label [String, Symbol] Label for the measurement
-      # @yield Block to measure
-      # @return [Object] Result of the block
       def measure(label)
         start_time = Time.now
         result = yield
@@ -218,8 +171,6 @@ module Snakommit
         result
       end
 
-      # Get a report of all timings
-      # @return [Array<String>] Formatted timing report lines
       def report
         @timings.sort_by { |_, v| -v }.map do |k, v|
           count = @counts[k]
@@ -228,8 +179,6 @@ module Snakommit
         end
       end
       
-      # Reset all timings
-      # @return [nil]
       def reset
         @timings.clear
         @counts.clear
@@ -239,11 +188,6 @@ module Snakommit
     
     # Benchmarking utility for snakommit operations
     class Benchmark
-      # Run a benchmark test
-      # @param label [String] Label for the benchmark
-      # @param iterations [Integer] Number of iterations to run
-      # @yield Block to benchmark
-      # @return [Hash] Benchmark results
       def self.run(label, iterations = 1)
         results = {}
         
@@ -262,12 +206,6 @@ module Snakommit
         results
       end
       
-      # Compare performance of multiple implementations
-      # @param options [Hash] Options for comparison
-      # @option options [Integer] :iterations Number of iterations
-      # @option options [Boolean] :verbose Print results
-      # @yield Block that returns a hash of callable objects to compare
-      # @return [Hash] Comparison results
       def self.compare(options = {})
         iterations = options[:iterations] || 100
         verbose = options[:verbose] || false
@@ -292,25 +230,15 @@ module Snakommit
     
     # Memory usage tracking
     class Memory
-      # Get current memory usage in KB
-      # @return [Integer] Memory usage in KB
       def self.usage
         case RbConfig::CONFIG['host_os']
-        when /linux/
+        when /linux/, /darwin/
           `ps -o rss= -p #{Process.pid}`.to_i
-        when /darwin/
-          `ps -o rss= -p #{Process.pid}`.to_i
-        when /windows|mswin|mingw/
-          # Not implemented for Windows
-          0
         else
           0
         end
       end
       
-      # Measure memory usage before and after a block execution
-      # @yield Block to measure
-      # @return [Hash] Memory usage statistics
       def self.measure
         before = usage
         result = yield