kaal-sequel 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 20b093d4e62a2bdb94bd8131189c55ecb4510d51cd2bbbf71ba2ba5befd998be
+  data.tar.gz: ae2ec7986d15202efc9d5ebb516642fb58a7b74bcde545221ed498afc076ce90
+SHA512:
+  metadata.gz: ec6475077d6c68a411832bade23b8fcc00d303b00cf6225da77dbe9d0f46fda50a4307271c1a4faf930a01eb51d9c794176216e82f23874efb795f3cde349ba1
+  data.tar.gz: 53cc4924945510e13288a7e9f6cac8324466d78dbf5d56721a07bdd48c95ee068504465209a0bfcc91c29ce86bfadefc70047df98700f3dfc2626b712dcee466

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-present Codevedas Inc. and the Kaal Authors
+
+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,69 @@
+# Kaal::Sequel
+
+Sequel-backed datastore adapter for Kaal.
+
+`kaal-sequel` depends on `kaal` and owns the Sequel persistence layer:
+
+- Sequel-backed definition registry
+- Sequel-backed dispatch registry
+- SQLite table-lock adapter
+- PostgreSQL advisory-lock adapter
+- MySQL named-lock adapter
+- Sequel migration templates for Kaal tables
+
+## Install
+
+```ruby
+gem 'kaal'
+gem 'kaal-sequel'
+```
+
+## Usage
+
+SQLite:
+
+```ruby
+require 'kaal'
+require 'kaal/sequel'
+require 'sequel'
+
+database = Sequel.connect(adapter: 'sqlite', database: 'db/kaal.sqlite3')
+
+Kaal.configure do |config|
+  config.backend = Kaal::Backend::DatabaseAdapter.new(database)
+  config.scheduler_config_path = 'config/scheduler.yml'
+end
+```
+
+PostgreSQL:
+
+```ruby
+config.backend = Kaal::Backend::PostgresAdapter.new(database)
+```
+
+MySQL:
+
+```ruby
+config.backend = Kaal::Backend::MySQLAdapter.new(database)
+```
+
+This is the plain Ruby SQL path when you want Sequel to own the tables, registries, and lock adapters without Rails.
+
+## Tables
+
+The Sequel adapter persists against:
+
+- `kaal_definitions`
+- `kaal_dispatches`
+- `kaal_locks`
+
+`kaal_locks` is used for SQLite. PostgreSQL and MySQL rely on advisory or named locks and persist definitions and dispatches without a dedicated locks table.
+
+## Development
+
+```bash
+bin/rspec-unit
+bin/rspec-e2e sqlite
+bin/rubocop
+bin/reek
+```

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/kaal/backend/database_adapter.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'sequel'
+require 'kaal/backend/dispatch_logging'
+require_relative '../definition/database_engine'
+require_relative '../dispatch/database_engine'
+require 'kaal/persistence/database'
+
+module Kaal
+  module Backend
+    # Sequel-backed SQL adapter that coordinates locks through the kaal_locks table.
+    class DatabaseAdapter < Adapter
+      include DispatchLogging
+
+      def initialize(database, namespace: nil)
+        super()
+        @database = Kaal::Persistence::Database.new(database)
+        @namespace = namespace
+      end
+
+      def dispatch_registry
+        @dispatch_registry ||= Kaal::Dispatch::DatabaseEngine.new(database: @database.connection, namespace: resolved_namespace)
+      end
+
+      def definition_registry
+        @definition_registry ||= Kaal::Definition::DatabaseEngine.new(database: @database.connection)
+      end
+
+      def acquire(key, ttl)
+        now = Time.now.utc
+        expires_at = now + ttl
+
+        2.times do |attempt|
+          cleanup_expired_locks if attempt.positive?
+
+          begin
+            dataset.insert(key: key, acquired_at: now, expires_at: expires_at)
+            log_dispatch_attempt(key)
+            return true
+          rescue ::Sequel::UniqueConstraintViolation
+            next
+          end
+        end
+
+        false
+      rescue StandardError => e
+        raise LockAdapterError, "Database acquire failed for #{key}: #{e.message}"
+      end
+
+      def release(key)
+        dataset.where(key: key).delete.positive?
+      rescue StandardError => e
+        raise LockAdapterError, "Database release failed for #{key}: #{e.message}"
+      end
+
+      def cleanup_expired_locks
+        dataset.where { expires_at < Time.now.utc }.delete
+      end
+
+      private
+
+      def dataset
+        @database.locks_dataset
+      end
+
+      def resolved_namespace
+        @namespace || Kaal.configuration.namespace
+      end
+    end
+
+    SQLiteAdapter = DatabaseAdapter
+  end
+end

data/lib/kaal/backend/mysql_adapter.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'digest'
+require 'kaal/backend/dispatch_logging'
+require_relative '../definition/database_engine'
+require_relative '../dispatch/database_engine'
+require 'kaal/persistence/database'
+
+module Kaal
+  module Backend
+    # MySQL named-lock adapter backed by Sequel.
+    class MySQLAdapter < Adapter
+      include DispatchLogging
+
+      MAX_LOCK_NAME_LENGTH = 64
+
+      def initialize(database, namespace: nil)
+        super()
+        @database = Kaal::Persistence::Database.new(database)
+        @namespace = namespace
+      end
+
+      def dispatch_registry
+        @dispatch_registry ||= Kaal::Dispatch::DatabaseEngine.new(database: @database.connection, namespace: resolved_namespace)
+      end
+
+      def definition_registry
+        @definition_registry ||= Kaal::Definition::DatabaseEngine.new(database: @database.connection)
+      end
+
+      def acquire(key, _ttl)
+        acquired = scalar('SELECT GET_LOCK(?, 0) AS lock_result', self.class.normalize_lock_name(key)) == 1
+        log_dispatch_attempt(key) if acquired
+        acquired
+      rescue StandardError => e
+        raise LockAdapterError, "MySQL acquire failed for #{key}: #{e.message}"
+      end
+
+      def release(key)
+        scalar('SELECT RELEASE_LOCK(?) AS lock_result', self.class.normalize_lock_name(key)) == 1
+      rescue StandardError => e
+        raise LockAdapterError, "MySQL release failed for #{key}: #{e.message}"
+      end
+
+      def self.normalize_lock_name(key)
+        return key if key.length <= MAX_LOCK_NAME_LENGTH
+
+        digest = Digest::SHA256.hexdigest(key)
+        prefix_length = MAX_LOCK_NAME_LENGTH - 17
+        "#{key[0...prefix_length]}:#{digest[0...16]}"
+      end
+
+      private
+
+      def scalar(sql, *binds)
+        row = @database.connection.fetch(sql, *binds).first
+        row.values.first
+      end
+
+      def resolved_namespace
+        @namespace || Kaal.configuration.namespace
+      end
+    end
+  end
+end

data/lib/kaal/backend/postgres_adapter.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'digest'
+require 'kaal/backend/dispatch_logging'
+require_relative '../definition/database_engine'
+require_relative '../dispatch/database_engine'
+require 'kaal/persistence/database'
+
+module Kaal
+  module Backend
+    # PostgreSQL advisory-lock adapter backed by Sequel.
+    class PostgresAdapter < Adapter
+      include DispatchLogging
+
+      SIGNED_64_MAX = 9_223_372_036_854_775_807
+      UNSIGNED_64_RANGE = 18_446_744_073_709_551_616
+
+      def initialize(database, namespace: nil)
+        super()
+        @database = Kaal::Persistence::Database.new(database)
+        @namespace = namespace
+      end
+
+      def dispatch_registry
+        @dispatch_registry ||= Kaal::Dispatch::DatabaseEngine.new(database: @database.connection, namespace: resolved_namespace)
+      end
+
+      def definition_registry
+        @definition_registry ||= Kaal::Definition::DatabaseEngine.new(database: @database.connection)
+      end
+
+      def acquire(key, _ttl)
+        acquired = scalar('SELECT pg_try_advisory_lock(?) AS acquired', self.class.calculate_lock_id(key)) == true
+        log_dispatch_attempt(key) if acquired
+        acquired
+      rescue StandardError => e
+        raise LockAdapterError, "PostgreSQL acquire failed for #{key}: #{e.message}"
+      end
+
+      def release(key)
+        scalar('SELECT pg_advisory_unlock(?) AS released', self.class.calculate_lock_id(key)) == true
+      rescue StandardError => e
+        raise LockAdapterError, "PostgreSQL release failed for #{key}: #{e.message}"
+      end
+
+      def self.calculate_lock_id(key)
+        hash = Digest::MD5.digest(key).unpack1('Q>')
+        hash > SIGNED_64_MAX ? hash - UNSIGNED_64_RANGE : hash
+      end
+
+      private
+
+      def scalar(sql, *binds)
+        row = @database.connection.fetch(sql, *binds).first
+        row.values.first
+      end
+
+      def resolved_namespace
+        @namespace || Kaal.configuration.namespace
+      end
+    end
+  end
+end

data/lib/kaal/backend/sqlite_adapter.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'kaal/backend/database_adapter'

data/lib/kaal/definition/database_engine.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'json'
+require 'kaal/definition/registry'
+require 'kaal/definition/persistence_helpers'
+require 'kaal/persistence/database'
+
+module Kaal
+  module Definition
+    # Sequel-backed definition registry persisted in kaal_definitions.
+    class DatabaseEngine < Registry
+      def initialize(database:)
+        super()
+        @database = Kaal::Persistence::Database.new(database)
+      end
+
+      def upsert_definition(key:, cron:, enabled: true, source: 'code', metadata: {})
+        rows = dataset.where(key: key)
+        existing = rows.first
+        now = Time.now.utc
+        payload = {
+          key: key,
+          cron: cron,
+          enabled: enabled,
+          source: source,
+          metadata: JSON.generate(metadata || {}),
+          created_at: existing ? existing[:created_at] : now,
+          updated_at: now,
+          disabled_at: PersistenceHelpers.disabled_at_for(existing, enabled, now)
+        }
+
+        if existing
+          rows.update(payload)
+        else
+          dataset.insert(payload)
+        end
+
+        find_definition(key)
+      end
+
+      def remove_definition(key)
+        rows = dataset.where(key: key)
+        row = rows.first
+        return nil unless row
+
+        rows.delete
+        self.class.normalize_row(row)
+      end
+
+      def find_definition(key)
+        self.class.normalize_row(dataset.where(key: key).first)
+      end
+
+      def all_definitions
+        dataset.order(:key).all.map { |row| self.class.normalize_row(row) }
+      end
+
+      def enabled_definitions
+        dataset.where(enabled: true).order(:key).all.map { |row| self.class.normalize_row(row) }
+      end
+
+      def self.normalize_row(row)
+        return nil unless row
+
+        {
+          key: row[:key],
+          cron: row[:cron],
+          enabled: row[:enabled] ? true : false,
+          source: row[:source],
+          metadata: PersistenceHelpers.parse_metadata(row[:metadata]),
+          created_at: row[:created_at],
+          updated_at: row[:updated_at],
+          disabled_at: row[:disabled_at]
+        }
+      end
+
+      private
+
+      def dataset
+        @database.definitions_dataset
+      end
+    end
+  end
+end

data/lib/kaal/dispatch/database_engine.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'kaal/dispatch/registry'
+require 'kaal/persistence/database'
+
+module Kaal
+  module Dispatch
+    # Sequel-backed dispatch registry stored in kaal_dispatches.
+    class DatabaseEngine < Registry
+      def initialize(database:, namespace: nil)
+        super()
+        @database = Kaal::Persistence::Database.new(database)
+        @namespace = namespace
+      end
+
+      def log_dispatch(key, fire_time, node_id, status = 'dispatched')
+        now = Time.now.utc
+        storage_key = namespaced_key(key)
+        attributes = {
+          key: storage_key,
+          fire_time: fire_time,
+          dispatched_at: now,
+          node_id: node_id,
+          status: status
+        }
+        dispatches_dataset = dataset
+        update_values = { dispatched_at: now, node_id: node_id, status: status }
+        begin
+          dispatches_dataset.insert_conflict(
+            target: %i[key fire_time],
+            update: update_values
+          ).insert(attributes)
+        rescue NoMethodError => e
+          raise unless e.name == :insert_conflict
+
+          begin
+            dispatches_dataset.insert(attributes)
+          rescue ::Sequel::UniqueConstraintViolation
+            dispatches_dataset.where(key: storage_key, fire_time: fire_time).update(update_values)
+          end
+        end
+
+        find_dispatch(key, fire_time)
+      end
+
+      def find_dispatch(key, fire_time)
+        self.class.normalize_row(dataset.where(key: namespaced_key(key), fire_time: fire_time).first, namespace: @namespace)
+      end
+
+      def find_by_key(key)
+        query(key: namespaced_key(key))
+      end
+
+      def find_by_node(node_id)
+        query(node_id: node_id)
+      end
+
+      def find_by_status(status)
+        query(status: status)
+      end
+
+      def cleanup(recovery_window: 86_400)
+        cutoff_time = Time.now.utc - recovery_window
+        cleanup_dataset.where { fire_time < cutoff_time }.delete
+      end
+
+      def self.normalize_row(row, namespace: nil)
+        return nil unless row
+
+        {
+          key: strip_namespace(row[:key], namespace:),
+          fire_time: row[:fire_time],
+          dispatched_at: row[:dispatched_at],
+          node_id: row[:node_id],
+          status: row[:status]
+        }
+      end
+
+      def self.strip_namespace(key, namespace:)
+        return key if namespace.to_s.empty?
+
+        prefix = "#{namespace}:"
+        key.start_with?(prefix) ? key.delete_prefix(prefix) : key
+      end
+
+      private
+
+      def dataset
+        @database.dispatches_dataset
+      end
+
+      def namespaced_key(key)
+        return key if @namespace.to_s.empty?
+
+        "#{@namespace}:#{key}"
+      end
+
+      def query(filters)
+        query_dataset(filters).reverse_order(:fire_time).all.map { |row| self.class.normalize_row(row, namespace: @namespace) }
+      end
+
+      def query_dataset(filters)
+        relation = dataset.where(filters)
+        return relation if @namespace.to_s.empty? || filters.key?(:key)
+
+        relation.where(::Sequel.lit('key LIKE ?', "#{@namespace}:%"))
+      end
+
+      def cleanup_dataset
+        return dataset if @namespace.to_s.empty?
+
+        dataset.where(::Sequel.lit('key LIKE ?', "#{@namespace}:%"))
+      end
+    end
+  end
+end

data/lib/kaal/persistence/database.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'sequel'
+
+module Kaal
+  module Persistence
+    # Thin wrapper around a Sequel connection to keep table access consistent.
+    class Database
+      attr_reader :connection
+
+      def initialize(connection)
+        @connection = if connection.is_a?(::Sequel::Database)
+                        connection
+                      else
+                        ::Sequel.connect(connection)
+                      end
+      end
+
+      def definitions_dataset
+        connection[:kaal_definitions]
+      end
+
+      def dispatches_dataset
+        connection[:kaal_dispatches]
+      end
+
+      def locks_dataset
+        connection[:kaal_locks]
+      end
+    end
+  end
+end

data/lib/kaal/persistence/migration_templates.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+module Kaal
+  module Persistence
+    # Sequel migration templates emitted by `kaal init`.
+    module MigrationTemplates
+      module_function
+
+      def for_backend(backend)
+        case backend.to_s
+        when 'sqlite'
+          {
+            '001_create_kaal_dispatches.rb' => dispatches_template,
+            '002_create_kaal_locks.rb' => locks_template,
+            '003_create_kaal_definitions.rb' => definitions_template
+          }
+        when 'postgres', 'mysql'
+          {
+            '001_create_kaal_dispatches.rb' => dispatches_template,
+            '002_create_kaal_definitions.rb' => definitions_template
+          }
+        else
+          {}
+        end
+      end
+
+      def dispatches_template
+        <<~RUBY
+          Sequel.migration do
+            change do
+              create_table?(:kaal_dispatches) do
+                primary_key :id
+                String :key, null: false
+                Time :fire_time, null: false
+                Time :dispatched_at, null: false
+                String :node_id, null: false
+                String :status, null: false, default: 'dispatched', size: 50
+              end
+
+              add_index :kaal_dispatches, [:key, :fire_time], unique: true
+              add_index :kaal_dispatches, :key
+              add_index :kaal_dispatches, :node_id
+              add_index :kaal_dispatches, :status
+              add_index :kaal_dispatches, :fire_time
+            end
+          end
+        RUBY
+      end
+
+      def locks_template
+        <<~RUBY
+          Sequel.migration do
+            change do
+              create_table?(:kaal_locks) do
+                primary_key :id
+                String :key, null: false
+                Time :acquired_at, null: false
+                Time :expires_at, null: false
+              end
+
+              add_index :kaal_locks, :key, unique: true
+              add_index :kaal_locks, :expires_at
+            end
+          end
+        RUBY
+      end
+
+      def definitions_template
+        <<~RUBY
+          Sequel.migration do
+            change do
+              create_table?(:kaal_definitions) do
+                primary_key :id
+                String :key, null: false
+                String :cron, null: false
+                TrueClass :enabled, null: false, default: true
+                String :source, null: false
+                String :metadata, text: true, null: false, default: '{}'
+                Time :disabled_at
+                Time :created_at, null: false
+                Time :updated_at, null: false
+              end
+
+              add_index :kaal_definitions, :key, unique: true
+              add_index :kaal_definitions, :enabled
+              add_index :kaal_definitions, :source
+            end
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/kaal/sequel/version.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+module Kaal
+  module Sequel
+    VERSION = '0.3.0'
+  end
+end

data/lib/kaal/sequel.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+require 'kaal'
+require 'sequel'
+require_relative 'sequel/version'
+require_relative 'backend/database_adapter'
+require_relative 'backend/postgres_adapter'
+require_relative 'backend/mysql_adapter'
+require_relative 'backend/sqlite_adapter'
+require 'kaal/definition/persistence_helpers'
+require_relative 'definition/database_engine'
+require_relative 'dispatch/database_engine'
+require_relative 'persistence/database'
+require_relative 'persistence/migration_templates'
+
+module Kaal
+  module Sequel
+    # Base error namespace for Sequel-backed Kaal integrations.
+    class Error < StandardError; end
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: kaal-sequel
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Nitesh Purohit
+- Codevedas Inc.
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: kaal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: "    Kaal-Sequel provides seamless integration of Kaal with Sequel, allowing
+  you to use Sequel models for scheduling and managing cron jobs in a distributed
+  environment.\n"
+email:
+- nitesh.purohit.it@gmail.com
+- team@codevedas.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/kaal/backend/database_adapter.rb
+- lib/kaal/backend/mysql_adapter.rb
+- lib/kaal/backend/postgres_adapter.rb
+- lib/kaal/backend/sqlite_adapter.rb
+- lib/kaal/definition/database_engine.rb
+- lib/kaal/dispatch/database_engine.rb
+- lib/kaal/persistence/database.rb
+- lib/kaal/persistence/migration_templates.rb
+- lib/kaal/sequel.rb
+- lib/kaal/sequel/version.rb
+homepage: https://github.com/Code-Vedas/kaal
+licenses:
+- MIT
+metadata:
+  bug_tracker_uri: https://github.com/Code-Vedas/kaal/issues
+  changelog_uri: https://github.com/Code-Vedas/kaal/blob/main/CHANGELOG.md
+  documentation_uri: https://kaal.codevedas.com
+  homepage_uri: https://github.com/Code-Vedas/kaal
+  source_code_uri: https://github.com/Code-Vedas/kaal.git
+  funding_uri: https://github.com/sponsors/Code-Vedas
+  support_uri: https://kaal.codevedas.com/support
+  rubygems_uri: https://rubygems.org/gems/kaal-sequel
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Sequel integration for Kaal, a distributed cron scheduler for Ruby.
+test_files: []