rails_soft_lock 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f6443555d20169a04a8c16dbe970b56fca4f3befe6a840bea0f1385e6783524
-  data.tar.gz: '08382ac46d6a3fe067e4899721da2b217ccd74065bf76061886509694ab6c85a'
+  metadata.gz: '059033a8b8115c0c301d705a1cfdeb412038ca9d7c5901fdba21400c591592c1'
+  data.tar.gz: febced8d04b074e5acb9a62d913e55d3e1e1b0e6c4328d957249e7bd7f98cb60
 SHA512:
-  metadata.gz: a1bd7a8346ccfc3e17b12f632847627bd313ae27bb2cc641e437524f932d708cd93f2edcf9e7694a8e5b9df81efab8b1c76006d67fb7508fe5ad5e8df48797d6
-  data.tar.gz: 892296a9f41bf10c6c61eca479b42bd6f79892cb2dfbe9762f978080b634630b34f97178759259f0efa20db7bbed25ac059403a83e44cf3febcc3175932f6fd6
+  metadata.gz: f0b8ea015e43aafd3c624831ad2fbbbde4fa50b733268ec51f2e00654e76165c3653a5112177b79cc537da785cc1603af8eb273227bac012856c69d6ce01ac2b
+  data.tar.gz: 42658703a0637fb10038f0bac0bdba3e3c06a710b60bb1539e2435c59ea1f27917c25ba8d06476672c2e64864c6f2cd50aaec52da6392dc3ce89057debeba91f

data/.reek.yml

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

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
 
@@ -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,7 +30,7 @@ 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

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.2.1"
 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.2.1
 platform: ruby
 authors:
 - Sergey Arkhipov
+- Georgy Shcherbakov
 - Vladimir Peskov
 bindir: lib
 cert_chain: []
-date: 2025-04-28 00:00:00.000000000 Z
+date: 2025-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: connection_pool
@@ -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"