de-dupe 0.0.1.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 87750b01e05633001daa17f7b5984b2dc6defaa9987b0bc67c028590794a0cee
+  data.tar.gz: 27af945d2ab33a01c9d27eb0050c067dd3970c0dba98fd28d90bc87203709a4b
+SHA512:
+  metadata.gz: '09edd34f392f56e7c3eb34fbf506725e9713a056c526c468a11f773702e3834bf836c867ce0d4173ee5d0586f26af661e0ca65aba523072b388c5f52c61128d4'
+  data.tar.gz: 0c02cbada386781ff4fb9cb61e1906573ecdf5a74be99b3a164692a9e683df4aea498a597e5d5c05d57b94351202a02a925f5b6fd8f57ea5c3dda94d2a085714

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,36 @@
+inherit_mode:
+  merge:
+    - Exclude
+
+require:
+  - rubocop-performance
+  - rubocop-rspec
+  - standard/cop/block_single_line_braces
+
+inherit_gem:
+  standard: config/base.yml
+
+AllCops:
+  TargetRubyVersion: 2.7
+  SuggestExtensions: false
+  Exclude:
+    - "db/**/*"
+    - "tmp/**/*"
+    - "vendor/**/*"
+    - "spec/support/hooks/notification.rb" # I'll refactor this rspec matcher to allow use things like an_instance_of
+  NewCops: enable
+
+RSpec/MultipleExpectations:
+  Enabled: false
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MultipleMemoizedHelpers:
+  Enabled: false
+
+RSpec/MessageSpies:
+  Enabled: false
+
+RSpec/StubbedMock:
+  Enabled: false

data/.standard.yml

@@ -0,0 +1,3 @@
+# For available configuration options, see:
+#   https://github.com/standardrb/standard
+ruby_version: 3.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Marcos G. Zimmermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,345 @@
+# DeDupe
+
+A Ruby gem for distributed deduplication and locking using Redis Sorted Sets. DeDupe provides a simple and efficient way to prevent duplicate execution of tasks across multiple processes or servers, with automatic TTL-based expiration and cleanup.
+
+## Features
+
+- 🔒 **Distributed Locking**: Prevent duplicate execution across multiple processes/servers
+- ⏱️ **TTL-based Expiration**: Automatic expiration of locks with configurable time-to-live
+- 🧹 **Automatic Cleanup**: Expired entries are automatically removed
+- 📦 **Multiple ID Management**: Handle multiple locks/IDs within the same namespace
+- 🚀 **Simple API**: Easy-to-use interface with block support
+- 🔄 **Redis-backed**: Uses Redis Sorted Sets for efficient storage and querying
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "de-dupe"
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install de-dupe
+```
+
+## Configuration
+
+Configure DeDupe with your Redis connection:
+
+```ruby
+require "de-dupe"
+require "connection_pool"
+
+DeDupe.configure do |config|
+  # Redis connection (supports ConnectionPool or Redis instance)
+  config.redis = ConnectionPool.new(size: 10, timeout: 1) do
+    Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379"))
+  end
+
+  # Namespace for all keys (default: "de-dupe")
+  config.namespace = "my-app"
+
+  # Default TTL in seconds (default: 300 = 5 minutes)
+  config.expires_in = 3600 # 1 hour
+end
+```
+
+### Configuration Options
+
+- `redis`: Redis connection instance or ConnectionPool (required)
+- `namespace`: Prefix for all Redis keys (default: `"de-dupe"`)
+- `expires_in`: Default TTL in seconds for locks (default: `300`)
+
+## Usage
+
+### Simple Locking with `DeDupe.acquire`
+
+The simplest way to use DeDupe is with the `acquire` method:
+
+```ruby
+# Prevent duplicate execution of a long-running job
+DeDupe.acquire("import", "user-12345", ttl: 3600) do
+  # This block will only execute if the lock can be acquired
+  # If another process is already running this, the block won't execute
+  import_user_data("user-12345")
+end
+
+# With multiple namespace levels
+DeDupe.acquire("import", "users", "batch-2024-01-01", ttl: 7200) do
+  process_batch("batch-2024-01-01")
+end
+```
+
+**Note**: The last argument is the lock ID, all previous arguments form the namespace.
+
+### Using the Lock Class
+
+For more control, use the `Lock` class directly:
+
+```ruby
+# Create a lock
+lock = DeDupe::Lock.new(
+  lock_key: "import:users",
+  lock_id: "user-12345",
+  ttl: 3600 # optional, uses config default if not provided
+)
+
+# Check if locked
+if lock.locked?
+  puts "Already processing"
+else
+  # Acquire the lock
+  if lock.acquire
+    begin
+      # Do work
+      process_user("user-12345")
+    ensure
+      # Always release
+      lock.release
+    end
+  end
+end
+
+# Or use with_lock for automatic release
+lock.with_lock do
+  # Block only executes if lock can be acquired
+  # Lock is automatically released after block execution (even on error)
+  process_user("user-12345")
+end
+```
+
+### Using the Dataset Class
+
+The `Dataset` class allows you to manage multiple IDs within the same namespace:
+
+```ruby
+# Create a dataset
+dataset = DeDupe::Dataset.new("import:users", ttl: 3600)
+
+# Acquire multiple IDs at once
+if dataset.acquire("user-1", "user-2", "user-3")
+  puts "All IDs acquired"
+end
+
+# Check which IDs are locked
+locked = dataset.locked_members("user-1", "user-2", "user-3")
+# => ["user-1", "user-2", "user-3"]
+
+# Check which IDs are unlocked
+unlocked = dataset.unlocked_members("user-1", "user-2", "user-3")
+# => []
+
+# Release specific IDs
+dataset.release("user-1", "user-2")
+
+# Check lock status for multiple IDs
+if dataset.locked?("user-1", "user-2", "user-3")
+  puts "At least one ID is locked"
+end
+
+# Flush all entries
+dataset.flush
+
+# Manually clean up expired entries
+dataset.flush_expired_members
+```
+
+## API Reference
+
+### `DeDupe.acquire(*keys, ttl: nil, &block)`
+
+Convenience method for acquiring a lock and executing a block.
+
+- `*keys`: Namespace components (last one becomes the lock_id)
+- `ttl`: Optional TTL in seconds (uses config default if not provided)
+- `&block`: Block to execute if lock is acquired
+
+**Returns**: Result of the block, or `nil` if lock couldn't be acquired
+
+### `DeDupe::Lock`
+
+#### `new(lock_key:, lock_id:, ttl: nil)`
+
+Create a new lock instance.
+
+- `lock_key`: Namespace/group for the lock
+- `lock_id`: Unique identifier within the namespace
+- `ttl`: Optional TTL in seconds
+
+#### `acquire` / `lock`
+
+Attempt to acquire the lock. Returns `true` if acquired, `false` if already exists.
+
+#### `release` / `unlock`
+
+Release the lock. Returns `true` if released, `false` if lock didn't exist.
+
+#### `locked?`
+
+Check if the lock is currently active (exists and not expired). Returns `true` or `false`.
+
+#### `with_lock(&block)`
+
+Acquire lock, execute block, and automatically release lock. Block only executes if lock can be acquired.
+
+- Returns block result if lock acquired, `nil` otherwise
+- Always releases lock, even if block raises an exception
+- Propagates exceptions from the block
+
+### `DeDupe::Dataset`
+
+#### `new(lock_key, ttl: nil)`
+
+Create a new dataset instance.
+
+- `lock_key`: Namespace for the dataset
+- `ttl`: Optional TTL in seconds
+
+#### `acquire(*ids)` / `lock(*ids)`
+
+Acquire locks for multiple IDs. Returns `true` if at least one ID was acquired.
+
+#### `release(*ids)` / `unlock(*ids)`
+
+Release locks for multiple IDs. Returns `true` if at least one ID was released.
+
+#### `locked?(*ids)`
+
+Check if any of the given IDs are locked. Returns `true` if at least one is locked.
+
+#### `locked_members(*ids)`
+
+Return array of IDs that are currently locked (not expired).
+
+#### `unlocked_members(*ids)`
+
+Return array of IDs that are unlocked (don't exist or expired).
+
+#### `flush`
+
+Remove all entries from the dataset.
+
+#### `flush_expired_members`
+
+Remove all expired entries from the dataset (automatically called during `acquire`).
+
+## Examples
+
+### Preventing Duplicate Job Execution
+
+```ruby
+# In a background job processor
+class ImportUserJob
+  def perform(user_id)
+    DeDupe.acquire("import", "user-#{user_id}", ttl: 3600) do
+      # Only one instance of this job will run per user_id
+      UserImporter.new(user_id).import
+    end
+  end
+end
+```
+
+### Batch Processing with Deduplication
+
+```ruby
+# Process a batch, ensuring each item is only processed once
+dataset = DeDupe::Dataset.new("batch:process-#{batch_id}", ttl: 7200)
+
+items_to_process.each do |item|
+  next if dataset.locked?(item.id) # Skip if already processing
+
+  if dataset.acquire(item.id)
+    begin
+      process_item(item)
+    ensure
+      dataset.release(item.id)
+    end
+  end
+end
+```
+
+### Rate Limiting with Locking
+
+```ruby
+# Ensure only one API call per user per minute
+user_id = current_user.id
+lock = DeDupe::Lock.new(
+  lock_key: "api:rate-limit",
+  lock_id: "user-#{user_id}",
+  ttl: 60 # 1 minute
+)
+
+unless lock.locked?
+  lock.with_lock do
+    make_api_call(user_id)
+  end
+else
+  puts "Rate limit: Please wait before making another request"
+end
+```
+
+### Parallel Processing Safety
+
+```ruby
+# Ensure only one worker processes a task, even in parallel environments
+task_id = "task-12345"
+
+DeDupe.acquire("workers", "process", task_id, ttl: 300) do
+  # This will only execute in one worker, even if multiple workers
+  # try to process the same task simultaneously
+  process_task(task_id)
+end
+```
+
+## How It Works
+
+DeDupe uses Redis Sorted Sets to store locks with expiration timestamps as scores:
+
+1. **Lock Acquisition**: When you acquire a lock, it's stored in Redis with a score of `current_time + ttl`
+2. **Lock Checking**: A lock is considered active if its score (expiration time) is greater than the current time
+3. **Automatic Cleanup**: Expired entries (where score <= current_time) are automatically removed
+4. **Distributed**: Since it uses Redis, locks work across multiple processes and servers
+
+## Requirements
+
+- Ruby >= 2.7
+- Redis server
+- `redis` gem
+- `zeitwerk` gem
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bundle install
+```
+
+Run tests:
+
+```bash
+bundle exec rspec
+```
+
+Run RuboCop:
+
+```bash
+bundle exec rubocop
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/marcosgz/de-dupe.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "standard/rake"
+
+task default: %i[spec standard]

data/lib/de-dupe.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "de_dupe"

data/lib/de_dupe/config.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "redis"
+require "yaml"
+
+module DeDupe
+  class Config
+    # Redis/ConnectionPool instance of a valid list of configs to build a new redis connection
+    attr_accessor :redis
+
+    # Namespace used to group group data stored by this package
+    attr_accessor :namespace
+
+    # The global TTL for the redis storage. Keep nil if you don't want to expire objects.
+    attr_accessor :expires_in
+
+    def initialize
+      @redis = nil
+      @namespace = "de-dupe"
+      @expires_in = 5 * 60 # 5 minutes
+    end
+  end
+end

data/lib/de_dupe/dataset.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module DeDupe
+  # Distributed deduplication dataset using Redis Sorted Set.
+  # Handle multiple entries within the same namespace.
+  # The current timestamp is used as the score for the entries
+  class Dataset
+    attr_reader :lock_key, :ttl
+
+    # @param lock_key [String] The key to store the dataset
+    # @param ttl [Integer] The time to live for the dataset in seconds
+    def initialize(lock_key, ttl: nil)
+      @lock_key = lock_key.to_s
+      @ttl = ttl || DeDupe.config.expires_in.to_i
+    end
+
+    def acquire(*ids)
+      return false if ids.empty?
+
+      flush_expired_members # Keep the dataset clean
+      score = expiration_score
+      redis_pool.with do |conn|
+        conn.zadd(lock_key, ids.map { |id| [score, id] }, nx: true) > 0
+      end
+    end
+    alias_method :lock, :acquire
+
+    def release(*ids)
+      return false if ids.empty?
+
+      redis_pool.with do |conn|
+        conn.zrem(lock_key, ids) > 0
+      end
+    end
+    alias_method :unlock, :release
+
+    def locked?(*ids)
+      return false if ids.empty?
+
+      redis_pool.with do |conn|
+        scores = conn.zmscore(lock_key, *ids).compact
+        return false if scores.empty?
+
+        current_time = now
+        scores.any? { |score| score.to_f >= current_time }
+      end
+    end
+
+    def unlocked_members(*ids)
+      return [] if ids.empty?
+
+      redis_pool.with do |conn|
+        scores = conn.zmscore(lock_key, *ids)
+        return ids if scores.nil? || scores.empty?
+
+        current_time = now
+        scores.each_with_index
+          .select { |score, idx| score.nil? || score.to_f <= current_time }
+          .map { |score, idx| ids[idx] }
+      end
+    end
+
+    def locked_members(*ids)
+      return [] if ids.empty?
+
+      redis_pool.with do |conn|
+        scores = conn.zmscore(lock_key, *ids)
+        return [] if scores.nil? || scores.empty?
+
+        current_time = now
+        scores.each_with_index
+          .select { |score, idx| score && score.to_f >= current_time }
+          .map { |score, idx| ids[idx] }
+      end
+    end
+
+    def flush
+      redis_pool.with do |conn|
+        conn.del(lock_key) > 0
+      end
+    end
+
+    def flush_expired_members
+      redis_pool.with do |conn|
+        conn.zremrangebyscore(lock_key, "-inf", "(#{now}") > 0
+      end
+    end
+
+    private
+
+    def expiration_score
+      now(append_seconds: ttl)
+    end
+
+    def now(append_seconds: 0)
+      Time.now.to_f + append_seconds
+    end
+
+    def redis_pool
+      DeDupe.redis_pool
+    end
+  end
+end

data/lib/de_dupe/lock.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module DeDupe
+  # Distributed deduplication lock using Redis Sorted Set.
+  # Allows multiple independent locks under the same namespace (lock_key).
+  class Lock
+    extend Forwardable
+    def_delegators :dataset, :lock_key, :ttl
+
+    attr_reader :dataset, :lock_id
+
+    # @param lock_key [String] Namespace/group for similar jobs (e.g., "import:users")
+    # @param lock_id  [String] Unique identifier within the namespace (e.g., digest)
+    # @param ttl      [Integer, nil] Lock duration in seconds (defaults to config.expires_in)
+    def initialize(lock_key:, lock_id:, ttl: nil)
+      @lock_id = lock_id.to_s
+      @dataset = Dataset.new(lock_key, ttl: ttl)
+    end
+
+    def acquire
+      dataset.acquire(lock_id)
+    end
+    alias_method :lock, :acquire
+
+    def release
+      dataset.release(lock_id)
+    end
+    alias_method :unlock, :release
+
+    def locked?
+      redis_pool.with do |conn|
+        score = conn.zscore(lock_key, lock_id)
+        return false unless score
+
+        score.to_f > now
+      end
+    end
+
+    def with_lock(&block)
+      return if locked?
+      return unless acquire
+
+      begin
+        yield
+      ensure
+        release
+      end
+    end
+
+    private
+
+    def redis_pool
+      DeDupe.redis_pool
+    end
+
+    def expiration_score
+      now(append_seconds: ttl)
+    end
+
+    def now(append_seconds: 0)
+      Time.now.to_f + append_seconds
+    end
+  end
+end

data/lib/de_dupe/lock_key.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module DeDupe
+  class LockKey
+    SEPARATOR = ":"
+
+    def initialize(*keys)
+      @keys = keys.map { |k| k.to_s.strip.downcase }
+    end
+
+    def to_s
+      [DeDupe.config.namespace, *keys].compact.join(SEPARATOR)
+    end
+
+    private
+
+    attr_reader :keys
+  end
+end

data/lib/de_dupe/redis_pool.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module DeDupe
+  class RedisPool
+    extend Forwardable
+    def_delegator :@connection, :with
+
+    module ConnectionPoolLike
+      def with
+        yield self
+      end
+    end
+
+    def initialize(connection)
+      if connection.respond_to?(:with)
+        @connection = connection
+      else
+        @connection = if connection.respond_to?(:client)
+          connection
+        else
+          ::Redis.new(*[connection].compact)
+        end
+        @connection.extend(ConnectionPoolLike)
+      end
+    end
+  end
+end

data/lib/de_dupe/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DeDupe
+  VERSION = "0.0.1.beta1"
+end

data/lib/de_dupe.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "redis"
+require "forwardable"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect "version" => "VERSION"
+loader.ignore("#{__dir__}/de-dupe.rb")
+loader.ignore("#{__dir__}/dedupe.rb")
+loader.log! if ENV["DEBUG"]
+loader.setup
+
+module DeDupe
+  class Error < StandardError; end
+
+  module_function
+
+  def config
+    @config ||= Config.new
+  end
+
+  def configure(&block)
+    return unless block
+
+    config.instance_eval(&block)
+    @redis_pool = nil
+    config
+  end
+
+  def acquire(*keys, **kwargs, &block)
+    id = keys.pop
+    if keys.empty?
+      raise Error, <<~ERROR.strip
+        You must provide the namespace + the identifier for the lock.
+
+        Example:
+        DeDupe.acquire("long-running-job", "1234567890", ttl: 50) do
+          # code to execute
+        end
+      ERROR
+    end
+
+    namespace = LockKey.new(*keys).to_s
+    lock = Lock.new(lock_key: namespace, lock_id: id, **kwargs)
+    lock.with_lock(&block)
+  end
+
+  def redis_pool
+    @redis_pool ||= RedisPool.new(config.redis)
+  end
+
+  def flush_all
+    keys.inject(0) do |total, (key, cli)|
+      total + cli.del(key)
+    end
+  end
+
+  def keys
+    Enumerator.new do |yielder|
+      redis_pool.with do |cli|
+        cli.keys("#{config.namespace}:*").each { |key| yielder.yield(key, cli) }
+      end
+    end
+  end
+end
+
+loader.eager_load

data/lib/dedupe.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "de-dupe"

data/mise.toml

@@ -0,0 +1,2 @@
+[tools]
+ruby = "2.7.8"

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: de-dupe
+version: !ruby/object:Gem::Version
+  version: 0.0.1.beta1
+platform: ruby
+authors:
+- Marcos G. Zimmermann
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-12-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  DeDupe is a Ruby gem for distributed deduplication and locking using Redis Sorted Sets.
+  It provides a simple and efficient way to prevent duplicate execution of tasks across
+  multiple processes or servers, with automatic TTL-based expiration and cleanup.
+
+  Features:
+  - Distributed locking across multiple processes/servers
+  - TTL-based automatic expiration
+  - Automatic cleanup of expired entries
+  - Multiple ID management within namespaces
+  - Simple API with block support
+email:
+- mgzmaster@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- ".standard.yml"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/de-dupe.rb
+- lib/de_dupe.rb
+- lib/de_dupe/config.rb
+- lib/de_dupe/dataset.rb
+- lib/de_dupe/lock.rb
+- lib/de_dupe/lock_key.rb
+- lib/de_dupe/redis_pool.rb
+- lib/de_dupe/version.rb
+- lib/dedupe.rb
+- mise.toml
+homepage: https://github.com/marcosgz/de-dupe
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/marcosgz/de-dupe
+  source_code_uri: https://github.com/marcosgz/de-dupe
+  changelog_uri: https://github.com/marcosgz/de-dupe/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.4.22
+signing_key:
+specification_version: 4
+summary: Distributed deduplication and locking using Redis Sorted Sets
+test_files: []