rails_soft_lock 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f6443555d20169a04a8c16dbe970b56fca4f3befe6a840bea0f1385e6783524
-  data.tar.gz: '08382ac46d6a3fe067e4899721da2b217ccd74065bf76061886509694ab6c85a'
+  metadata.gz: 28c11572b431bdc87a2f4771c63b6aef7665f619761c84949d0265b73f2976d1
+  data.tar.gz: a81700f090a280d04f43d96dbac00603dc64fbd7912a7e22f69a76321792a57d
 SHA512:
-  metadata.gz: a1bd7a8346ccfc3e17b12f632847627bd313ae27bb2cc641e437524f932d708cd93f2edcf9e7694a8e5b9df81efab8b1c76006d67fb7508fe5ad5e8df48797d6
-  data.tar.gz: 892296a9f41bf10c6c61eca479b42bd6f79892cb2dfbe9762f978080b634630b34f97178759259f0efa20db7bbed25ac059403a83e44cf3febcc3175932f6fd6
+  metadata.gz: 824828fb615e0e17866a4ebf266f493f3283876e6e83fb485afdfde89beae8a748ba9ab6e7afec273344572385b0853b2707943fc4f64692961174a8baae6c4e
+  data.tar.gz: 1dcea30302c83b22c3782aeabf7307a3c931a7c6355b39f62726dd277630a472eb441200369426fa64a55dc04d124b65f18033a3a8524f24ebaf5ba5b65439e6

data/.reek.yml

@@ -0,0 +1,4 @@
+detectors:
+  UncommunicativeVariableName:
+    accept:
+      - e

data/.ruby-version

@@ -1 +1 @@
-ruby-3.4.1
+ruby-4.0.1

data/Rakefile

@@ -9,4 +9,8 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-task default: %i[spec rubocop]
+require "reek/rake/task"
+
+Reek::Rake::Task.new
+
+task default: %i[spec rubocop reek]

data/lib/rails_soft_lock/configuration.rb

@@ -2,41 +2,38 @@
 
 # lib/rails_soft_lock/configuration.rb
 module RailsSoftLock
-  # Configuration class for RailsSoftLock gem.
+  # Configuration for global settings like adapter and user class.
   class Configuration
-    # List of supported adapters.
+    # Supported storage adapters.
     VALID_ADAPTERS = %i[redis nats memcached].freeze
-    attr_reader :adapter
-    # :reek:Attribute
-    attr_accessor :adapter_options
+
+    attr_reader :adapter, :adapter_options
     # :reek:Attribute
     attr_writer :locked_by_class
 
+    # Initializes configuration with default values.
     def initialize
-      @adapter = :redis # Default adapter
-      @adapter_options ||= RedisConfig.default_adapter_options # Default adapter options
+      @adapter = :redis
+      @adapter_options = RedisConfig.default_adapter_options
       @locked_by_class = locked_by_class || "User"
     end
 
-    def acts_as_locked_by(attribute = :lock_attribute, scope: -> { "none" })
-      @acts_as_locked_options = { by: attribute, scope: scope }
-    end
-
-    def acts_as_locked_attribute
-      @acts_as_locked_options&.[](:by) || :lock_attribute
-    end
-
-    def acts_as_locked_scope
-      @acts_as_locked_options&.[](:scope)&.call || "none"
+    def adapter_options=(options = {})
+      @adapter_options = options.empty? ? RedisConfig.default_adapter_options : options
     end
 
+    # Returns the locker class constant (e.g., User).
+    #
+    # @return [Class]
     def locked_by_class
       @locked_by_class.is_a?(String) ? @locked_by_class.constantize : @locked_by_class
     end
 
-    # Sets the adapter and validates it.
-    # @param value [Symbol] The adapter to use.
-    # @raise [ArgumentError] If the adapter is not supported.
+    # Sets the adapter (e.g., :redis, :nats, :memcached).
+    #
+    # @param value [Symbol] one of the VALID_ADAPTERS
+    # @raise [ArgumentError] if adapter is not valid
+    # @return [void]
     def adapter=(value)
       raise ArgumentError, "Adapter must be one of: #{VALID_ADAPTERS.join(", ")}" unless VALID_ADAPTERS.include?(value)
 

data/lib/rails_soft_lock/lock_object.rb

@@ -9,17 +9,20 @@ module RailsSoftLock
   #   - object_key: The identifier of the lock instance, typically a unique database record ID
   #   - object_value: The identifier of the locker that locked the record
   class LockObject
-    # Attach adapter based on config
+    # Maps adapter symbols to their respective modules
+    ADAPTER_MAP = {
+      redis: RailsSoftLock::RedisAdapter
+      # nats: RailsSoftLock::NatsAdapter,
+      # memcached: RailsSoftLock::MemcachedAdapter
+    }.freeze
+
+    # Selects and returns the adapter module based on current configuration.
+    #
+    # @return [Module] adapter module (e.g., RedisAdapter)
+    # @raise [ArgumentError] if adapter is not recognized
     def self.adapter
-      case RailsSoftLock.configuration.adapter
-      when :redis
-        RailsSoftLock::RedisAdapter
-      when :nats
-        RailsSoftLock::NatsAdapter
-      when :memcached
-        RailsSoftLock::MemcachedAdapter
-      else
-        raise ArgumentError, "Unknown adapter: #{RailsSoftLock.configuration.adapter}"
+      ADAPTER_MAP.fetch(RailsSoftLock.configuration.adapter) do |key|
+        raise ArgumentError, "Unknown adapter: #{key}"
       end
     end
 
@@ -30,7 +33,7 @@ module RailsSoftLock
     def initialize(object_name:, object_key: nil, object_value: nil)
       @object_name = object_name
       @object_key = object_key
-      @object_value = object_value.present? ? object_value.to_s : nil # Convert to string for consistency
+      @object_value = object_value.presence&.to_s # Convert to string for consistency
     end
 
     # Returns the ID of the locker who locked the object
@@ -43,7 +46,7 @@ module RailsSoftLock
     # @return [Hash] { has_locked: Boolean, locked_by: String or nil }
     def lock_or_find
       locked_object = get
-      { has_locked: create, locked_by: locked_object || object_value }
+      { has_locked: !create, locked_by: locked_object || object_value }
     end
 
     # Unlocks the object

data/lib/rails_soft_lock/model_extensions.rb

@@ -1,74 +1,119 @@
 # frozen_string_literal: true
 
 # lib/rails_soft_lock/model_extensions.rb
-
 module RailsSoftLock
   # Extend model and give methods from gem
   module ModelExtensions
     extend ActiveSupport::Concern
+
+    included do
+      class_attribute :locked_attribute, default: :id
+      class_attribute :lock_scope_proc, default: -> { "none" }
+
+      delegate :object_name, to: :class
+    end
+
     class_methods do
-      # :reek:UtilityFunction
-      def acts_as_locked_by(attribute = :lock_attribute, scope: -> { "none" })
-        RailsSoftLock.configuration.acts_as_locked_by(attribute, scope: scope)
+      # Defines which attribute to use for locking and an optional scoping block.
+      #
+      # @param attribute [Symbol] the attribute used for locking (default: :id)
+      # @param scope [Proc] a proc returning the scoping value (default: -> { "none" })
+      # @return [void]
+      def acts_as_locked_by(attribute = nil, scope: nil)
+        unless attribute
+          raise InvalidArgumentError,
+                "[RailsSoftLock.acts_as_locked_by] Argument 'attribute' is required"
+        end
+
+        self.locked_attribute = attribute
+        self.lock_scope_proc  = scope if scope
       end
 
+      # Fetches all locks for the model.
+      #
+      # @return [Hash]
       def all_locks
-        RailsSoftLock::LockObject.new(object_name: object_name).all_locks
+        LockObject.new(object_name: object_name).all_locks
       end
 
+      # Unlocks a specific object key.
+      #
+      # @param object_key [String, Integer]
+      # @return [Boolean]
       def unlock(object_key)
-        RailsSoftLock::LockObject.new(object_name: object_name, object_key: object_key).unlock
+        LockObject.new(object_name: object_name, object_key: object_key).unlock
       end
 
+      # Returns the composed object name (model + scope).
+      #
+      # @return [String]
       def object_name
-        scope = RailsSoftLock.configuration.acts_as_locked_scope
-        "#{name}::#{scope}"
+        "#{name}::#{lock_scope_proc&.call}"
       end
     end
 
-    included do # rubocop:disable Metrics/BlockLength
-      delegate :object_name, to: :class
-
-      def lock_or_find(user)
-        lock_object_for(user).lock_or_find
-      end
+    # Attempts to acquire a lock for the given user.
+    #
+    # @param user [User]
+    # @return [Hash]
+    def lock_or_find(user)
+      lock_object_for(user).lock_or_find
+    end
 
-      def unlock(user)
-        lock_object_for(user).unlock
-      end
+    # Unlocks the object for the given user.
+    #
+    # @param user [User]
+    # @return [Boolean]
+    def unlock(user)
+      lock_object_for(user).unlock
+    end
 
-      def locked?
-        locked_by.present?
-      end
+    # Checks if the object is locked.
+    #
+    # @return [Boolean]
+    def locked?
+      locked_by.present?
+    end
 
-      def locked_by
-        user_id = base_lock_object.locked_by&.to_i
-        user_id ? RailsSoftLock.configuration.locked_by_class.find_by(id: user_id) : nil
-      end
+    # Returns the user who locked the object, if any.
+    #
+    # @return [User, nil]
+    def locked_by
+      user_id = base_lock_object.locked_by&.to_i
+      user_id ? RailsSoftLock.configuration.locked_by_class.find_by(id: user_id) : nil
+    end
 
-      def object_key
-        attribute = RailsSoftLock.configuration.acts_as_locked_attribute
-        raise ArgumentError, "No locked attribute defined" if attribute == :none
+    # Returns the lock attribute value for the instance.
+    #
+    # @return [Object]
+    def object_key
+      model = self.class
+      attribute = model.locked_attribute
 
-        send(attribute)
+      if (value = try(attribute))
+        value
+      else
+        raise NoMethodError,
+              "[RailsSoftLock.object_key] Model #{model} does not respond to :#{attribute}"
       end
+    end
 
-      private
+    private
 
-      def lock_object_for(user)
-        RailsSoftLock::LockObject.new(
-          object_name: object_name,
-          object_key: object_key,
-          object_value: user.id.to_s
-        )
-      end
+    def lock_object_for(user)
+      build_lock_object(object_value: user.id.to_s)
+    end
 
-      def base_lock_object
-        RailsSoftLock::LockObject.new(
-          object_name: object_name,
-          object_key: object_key
-        )
-      end
+    def base_lock_object
+      build_lock_object
+    end
+
+    def build_lock_object(object_value: nil)
+      RailsSoftLock::LockObject.new(
+        object_name: object_name,
+        object_key: object_key,
+        object_value: object_value
+      )
     end
   end
 end

data/lib/rails_soft_lock/redis_adapter.rb

@@ -9,21 +9,9 @@ module RailsSoftLock
   # Adapter for store lock in redis
   module RedisAdapter
     # Initialize Redis client
-    def redis_client # rubocop:disable Metrics/MethodLength
+    def redis_client
       @redis_client ||= begin
-        redis_config = RailsSoftLock.configuration.adapter_options.fetch(:redis, {})
-
-        # Set config defaults
-        defaults = {
-          url: "redis://localhost:6379/0",
-          timeout: 5
-        }
-        # Merge config options
-        config = defaults.merge(redis_config)
-
-        ConnectionPool::Wrapper.new do
-          Redis.new(**config)
-        end
+        ConnectionPool::Wrapper.new { Redis.new(**RailsSoftLock.configuration.adapter_options[:redis]) }
       rescue Redis::CannotConnectError => e
         raise RailsSoftLock::Error, "Failed to connect to Redis: #{e.message}"
       end
@@ -42,19 +30,19 @@ module RailsSoftLock
         transaction.hsetnx(@object_name, @object_key, @object_value)
         transaction.hget(@object_name, @object_key)
       end
-      !result.first # has_locked - false id created
+      result.first # true on creation, false otherwise
     end
 
     # Updates the value for an existing key or creates a new key-value pair
     # @return [Boolean] true if the key was updated, false if it was created
-    def update
+    def update # rubocop:disable Naming/PredicateMethod
       result = redis_client.hset(@object_name, @object_key, @object_value)
       result.zero?
     end
 
     # Deletes a key from the specified hash
     # @return [Boolean] true if the key was deleted, false if it did not exist
-    def delete
+    def delete # rubocop:disable Naming/PredicateMethod
       result = redis_client.hdel(@object_name, @object_key)
       !result.zero?
     end

data/lib/rails_soft_lock/redis_config.rb

@@ -18,6 +18,13 @@ module RailsSoftLock
       { redis: config_with_defaults }
     end
 
+    # The default Redis connection settings
+    # @return [Hash]
+    # @api private
+    def default_settings
+      { url: "redis://localhost:6379/0", timeout: 5 }
+    end
+
     # Merges default settings with any Rails-specific configuration
     # @return [Hash] Complete Redis configuration
     # @note Will return just defaults if Rails isn't available
@@ -29,13 +36,7 @@ module RailsSoftLock
     # Checks if Rails environment is available and properly configured
     # @return [Boolean]
     def rails_available?
-      if defined?(Rails) &&
-         Rails.respond_to?(:application) &&
-         Rails.application
-        true
-      else
-        false
-      end
+      !!(defined?(Rails) && Rails.try(:application).present?)
     end
 
     # Attempts to load Redis config from Rails application
@@ -55,14 +56,7 @@ module RailsSoftLock
     # @return [Boolean]
     # @api private
     def rails_config_available?
-      Rails.application.respond_to?(:config_for)
-    end
-
-    # The default Redis connection settings
-    # @return [Hash]
-    # @api private
-    def default_settings
-      { url: "redis://localhost:6379/0", timeout: 5 }
+      !!Rails.application.try(:config_for, :redis)
     end
   end
 end

data/lib/rails_soft_lock/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RailsSoftLock
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/rails_soft_lock.rb

@@ -8,6 +8,10 @@ require "zeitwerk"
 module RailsSoftLock
   # Error class for gem
   class Error < StandardError; end
+  # Error class for Argument required error
+  class InvalidArgumentError < Error; end
+  # Error class for undef attribute for Model class
+  class NoMethodError < Error; end
 
   def self.lock_manager(object_name:, object_key: nil, object_value: nil)
     @lock_manager ||= LockObject.new(

metadata

@@ -1,14 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rails_soft_lock
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Sergey Arkhipov
+- Georgy Shcherbakov
 - Vladimir Peskov
 bindir: lib
 cert_chain: []
-date: 2025-04-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -16,14 +17,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.5'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -41,11 +42,13 @@ dependencies:
 description: Using In-Memory Databases to Work with Rails Active Record Locks
 email:
 - sergey-arkhipov@ya.ru
+- lordsynergymail@gmail.com
 - v.peskov@mail.ru
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".reek.yml"
 - ".rspec"
 - ".rubocop.yml"
 - ".ruby-version"
@@ -81,14 +84,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.3.0
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Lock Active record by attribyte using in-memory adapters
 test_files: []