spikard 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cfc01cd2450315beba3567c74c86a3a8a05077f7fd92444b8831dd03fcfa608b
-  data.tar.gz: b4d4261fc98b7a911e667c3653d1137109aa3442fa8bf929180ea74034a171ec
+  metadata.gz: e1f75c9c00309eba12ce9edad11b8469746dcb1eba392f2987e522816dbdf9a0
+  data.tar.gz: cad1676a6d180be90cbf412d54470eb0a582eb0f65e7a880cdc546c3ab14a52e
 SHA512:
-  metadata.gz: 3ccd8095e1cbb20162673f215cd19c8109e396b8e77c20290cc6695c64e74f63c2c45624b90924a1dd388ee3466283c3862fb581f3c630e0eb6e2e0c1307ba09
-  data.tar.gz: fcd2b7a2ed7416458326a1e2024e1ad6de2fef41179f6f6c4a560a702a7693bc3bed1ca408b7eccc5f552fc6e8e8c1d70a22e6d28abd15a281eaff8a7bbdc368
+  metadata.gz: a8af5d8195a604c05fc4b5f3c9e20bce22f92f31db1b5a025a30aa971f94cb4cf8c5ecec2bfa2f7626aff0267ad21b4b4a0e12ee1659e856ca4277dea93451e1
+  data.tar.gz: d4ccbff9878b866119b20800223dc82e6cb744fe2a06fccc8c6017826c3ea1ec1810618c0143e513e6304a655dae536d23b6856777749be2053603e1a19b2f4d

data/README.md

@@ -1,16 +1,40 @@
 # Spikard Ruby
 
-[![Discord](https://img.shields.io/badge/Discord-Join%20our%20community-7289da)](https://discord.gg/pXxagNK2zN)
-[![RubyGems](https://badge.fury.io/rb/spikard.svg)](https://rubygems.org/gems/spikard)
-[![npm](https://img.shields.io/npm/v/spikard)](https://www.npmjs.com/package/spikard)
-[![npm (WASM)](https://img.shields.io/npm/v/spikard-wasm?label=npm%20%28wasm%29)](https://www.npmjs.com/package/spikard-wasm)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-
-High-performance Ruby web framework with a Rust core. Build REST APIs with Sinatra-style blocks backed by Axum and Tower-HTTP.
+[![Documentation](https://img.shields.io/badge/docs-spikard.dev-58FBDA)](https://spikard.dev)
+[![Gem Version](https://img.shields.io/gem/v/spikard.svg)](https://rubygems.org/gems/spikard)
+[![Gem Downloads](https://img.shields.io/gem/dt/spikard.svg)](https://rubygems.org/gems/spikard)
+[![Ruby Version](https://img.shields.io/badge/ruby-%3E%3D%203.2-red.svg)](https://www.ruby-lang.org/)
+[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+[![CI Status](https://img.shields.io/github/actions/workflow/status/Goldziher/spikard/ci.yml?branch=main)](https://github.com/Goldziher/spikard/actions)
+[![PyPI](https://img.shields.io/pypi/v/spikard.svg)](https://pypi.org/project/spikard/)
+[![npm](https://img.shields.io/npm/v/@spikard/node.svg)](https://www.npmjs.com/package/@spikard/node)
+[![Crates.io](https://img.shields.io/crates/v/spikard.svg)](https://crates.io/crates/spikard)
+[![Packagist](https://img.shields.io/packagist/v/spikard/spikard.svg)](https://packagist.org/packages/spikard/spikard)
+
+High-performance Ruby web framework with a Rust core. Build REST APIs with Sinatra-style routing and zero-overhead async handlers backed by Axum and Tower-HTTP.
+
+## Features
+
+- **Rust-powered performance**: High-throughput HTTP server backed by Tokio and Axum
+- **Sinatra-style routing**: Familiar `get`, `post`, `put`, `patch`, `delete` DSL
+- **Type-safe with RBS**: Full RBS type definitions for Steep type checking
+- **Zero-copy serialization**: Direct Rust-to-Ruby object conversion via Magnus
+- **Async-first**: Non-blocking handlers with full async/await support
+- **Middleware stack**: Compression, rate limiting, request IDs, authentication
+- **WebSockets & SSE**: Native real-time communication primitives
+- **Request validation**: JSON Schema and dry-schema support
+- **Lifecycle hooks**: onRequest, preValidation, preHandler, onResponse, onError
+- **Dependency injection**: Built-in container for services and factories
 
 ## Installation
 
-**From source (currently):**
+**Via RubyGems (recommended):**
+
+```bash
+gem install spikard
+```
+
+**From source (development):**
 
 ```bash
 cd packages/ruby
@@ -19,14 +43,20 @@ bundle exec rake ext:build
 ```
 
 **Requirements:**
-- Ruby 3.2+
+- Ruby 3.2 or later
 - Bundler
-- Rust toolchain (for building native extension)
+- Rust toolchain (for building from source)
 
 ## Quick Start
 
 ```ruby
 require "spikard"
+require "dry-schema"
+
+UserSchema = Dry::Schema.JSON do
+  required(:name).filled(:str?)
+  required(:email).filled(:str?)
+end
 
 app = Spikard::App.new
 
@@ -35,8 +65,9 @@ app.get "/users/:id" do |request|
   { id: user_id, name: "Alice" }
 end
 
-app.post "/users" do |request|
-  { id: 1, name: request[:body]["name"] }
+app.post "/users", request_schema: UserSchema do |request|
+  body = request[:body]
+  { id: 1, name: body["name"], email: body["email"] }
 end
 
 app.run(port: 8000)
@@ -171,6 +202,21 @@ app.post "/users", request_schema: user_schema do |request|
 end
 ```
 
+## Dependency Injection
+
+Register values or factories and inject them as keyword parameters:
+
+```ruby
+app.provide("config", { "db_url" => "postgresql://localhost/app" })
+app.provide("db_pool", depends_on: ["config"], singleton: true) do |config:|
+  { url: config["db_url"], driver: "pool" }
+end
+
+app.get "/stats" do |_params, _query, _body, config:, db_pool:|
+  { db: db_pool[:url], env: config["db_url"] }
+end
+```
+
 ### With dry-struct
 
 ```ruby
@@ -540,14 +586,41 @@ Ruby bindings use:
 
 ## Examples
 
-See `/examples/ruby/` for more examples.
+The [examples directory](../../examples/) contains comprehensive demonstrations:
+
+**Ruby-specific examples:**
+- [Basic Ruby Example](../../examples/di/ruby_basic.rb) - Simple server with DI
+- [Database Integration](../../examples/di/ruby_database.rb) - DI with database pools
+- Additional examples in [examples/](../../examples/)
+
+**API Schemas** (language-agnostic, can be used with code generation):
+- [Todo API](../../examples/schemas/todo-api.openapi.yaml) - REST CRUD with validation
+- [File Service](../../examples/schemas/file-service.openapi.yaml) - File uploads/downloads
+- [Auth Service](../../examples/schemas/auth-service.openapi.yaml) - JWT, API keys, OAuth
+- [Chat Service](../../examples/schemas/chat-service.asyncapi.yaml) - WebSocket messaging
+- [Event Streams](../../examples/schemas/events-stream.asyncapi.yaml) - SSE streaming
+
+See [examples/README.md](../../examples/README.md) for code generation instructions.
 
 ## Documentation
 
-- [Main Project README](../../README.md)
-- [Contributing Guide](../../CONTRIBUTING.md)
-- [RBS Type Signatures](sig/spikard.rbs)
+**API Reference & Guides:**
+- [Type Definitions (RBS)](sig/spikard.rbs) - Full type signatures for Steep
+- [Configuration Reference](lib/spikard/config.rb) - ServerConfig and middleware options
+- [Handler Documentation](lib/spikard/handler_wrapper.rb) - Request/response handling
+
+**Project Resources:**
+- [Main Project README](../../README.md) - Spikard overview and multi-language ecosystem
+- [Contributing Guide](../../CONTRIBUTING.md) - Development guidelines
+- [Architecture Decisions](../../docs/adr/) - ADRs on design choices
+- [Examples](../../examples/ruby/) - Runnable example applications
+
+**Cross-Language:**
+- [Python (PyPI)](https://pypi.org/project/spikard/)
+- [Node.js (npm)](https://www.npmjs.com/package/@spikard/node)
+- [Rust (Crates.io)](https://crates.io/crates/spikard)
+- [PHP (Packagist)](https://packagist.org/packages/spikard/spikard)
 
 ## License
 
-MIT
+MIT - See [LICENSE](../../LICENSE) for details

data/ext/spikard_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-rb-ext"
-version = "0.1.1"
+version = "0.2.0"
 edition = "2024"
 license = "MIT"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

data/lib/spikard/app.rb

@@ -120,6 +120,7 @@ module Spikard
   # rubocop:disable Metrics/ClassLength
   class App
     include LifecycleHooks
+    include ProvideSupport
 
     HTTP_METHODS = %w[GET POST PUT PATCH DELETE OPTIONS HEAD TRACE].freeze
     SUPPORTED_OPTIONS = %i[request_schema response_schema parameter_schema file_params is_async cors].freeze
@@ -130,6 +131,7 @@ module Spikard
       @routes = []
       @websocket_handlers = {}
       @sse_producers = {}
+      @dependencies = {}
       @lifecycle_hooks = {
         on_request: [],
         pre_validation: [],
@@ -142,7 +144,11 @@ module Spikard
     def register_route(method, path, handler_name: nil, **options, &block)
       validate_route_arguments!(block, options)
       handler_name ||= default_handler_name(method, path)
-      metadata = build_metadata(method, path, handler_name, options)
+
+      # Extract handler dependencies from block parameters
+      handler_dependencies = extract_handler_dependencies(block)
+
+      metadata = build_metadata(method, path, handler_name, options, handler_dependencies)
 
       @routes << RouteEntry.new(metadata, block)
       block
@@ -155,13 +161,24 @@ module Spikard
     end
 
     def route_metadata
-      @routes.map(&:metadata)
+      # Extract handler dependencies when metadata is requested
+      # This allows dependencies to be registered after routes
+      @routes.map do |entry|
+        metadata = entry.metadata.dup
+
+        # Re-extract dependencies in case they were registered after the route
+        handler_dependencies = extract_handler_dependencies(entry.handler)
+        metadata[:handler_dependencies] = handler_dependencies unless handler_dependencies.empty?
+
+        metadata
+      end
     end
 
     def handler_map
       map = {}
       @routes.each do |entry|
         name = entry.metadata[:handler_name]
+        # Pass raw handler - DI resolution happens in Rust layer
         map[name] = entry.handler
       end
       map
@@ -270,8 +287,11 @@ module Spikard
       ws_handlers = websocket_handlers
       sse_prods = sse_producers
 
+      # Get dependencies for DI
+      deps = dependencies
+
       # Call the Rust extension's run_server function
-      Spikard::Native.run_server(routes_json, handlers, config, hooks, ws_handlers, sse_prods)
+      Spikard::Native.run_server(routes_json, handlers, config, hooks, ws_handlers, sse_prods, deps)
 
       # Keep Ruby process alive while server runs
       sleep
@@ -309,7 +329,30 @@ module Spikard
       raise ArgumentError, "unknown route options: #{unknown_keys.join(', ')}"
     end
 
-    def build_metadata(method, path, handler_name, options)
+    def extract_handler_dependencies(block)
+      # Get the block's parameters
+      params = block.parameters
+
+      # Extract keyword parameters (dependencies)
+      # Parameters come in the format [:req/:opt/:keyreq/:key, :param_name]
+      # :keyreq and :key are keyword parameters (required and optional)
+      dependencies = []
+
+      params.each do |param_type, param_name|
+        # Skip the request parameter (usually first positional param)
+        # Only collect keyword parameters
+        next unless %i[keyreq key].include?(param_type)
+
+        dep_name = param_name.to_s
+        # Collect ALL keyword parameters, not just registered ones
+        # This allows the DI system to validate missing dependencies
+        dependencies << dep_name
+      end
+
+      dependencies
+    end
+
+    def build_metadata(method, path, handler_name, options, handler_dependencies)
       base = {
         method: method,
         path: normalize_path(path),
@@ -317,6 +360,9 @@ module Spikard
         is_async: options.fetch(:is_async, false)
       }
 
+      # Add handler_dependencies if present
+      base[:handler_dependencies] = handler_dependencies unless handler_dependencies.empty?
+
       SUPPORTED_OPTIONS.each_with_object(base) do |key, metadata|
         next if key == :is_async || !options.key?(key)
 

data/lib/spikard/provide.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module Spikard
+  # Wrapper class for dependency providers
+  #
+  # This class wraps factory functions and configuration for dependency injection.
+  # It provides a consistent API across Python, Node.js, and Ruby bindings.
+  #
+  # @example Factory with caching
+  #   app.provide("db", Spikard::Provide.new(method("create_db"), cacheable: true))
+  #
+  # @example Factory with dependencies
+  #   app.provide("auth", Spikard::Provide.new(
+  #     method("create_auth_service"),
+  #     depends_on: ["db", "cache"],
+  #     singleton: true
+  #   ))
+  class Provide
+    attr_reader :factory, :depends_on, :singleton, :cacheable
+
+    # Create a new dependency provider
+    #
+    # @param factory [Proc, Method] The factory function that creates the dependency value
+    # @param depends_on [Array<String, Symbol>] List of dependency keys this factory depends on
+    # @param singleton [Boolean] Whether to cache the value globally (default: false)
+    # @param cacheable [Boolean] Whether to cache the value per-request (default: true)
+    def initialize(factory, depends_on: [], singleton: false, cacheable: true)
+      @factory = factory
+      @depends_on = Array(depends_on).map(&:to_s)
+      @singleton = singleton
+      @cacheable = cacheable
+    end
+
+    # Check if the factory is async (based on method arity or other heuristics)
+    #
+    # @return [Boolean] True if the factory appears to be async
+    def async?
+      # Ruby doesn't have explicit async/await like Python/JS
+      # We could check if it returns a Thread or uses Fiber
+      false
+    end
+
+    # Check if the factory is an async generator
+    #
+    # @return [Boolean] True if the factory is an async generator
+    def async_generator?
+      false
+    end
+  end
+
+  # Dependency Injection support for Spikard applications
+  #
+  # Provides methods for registering and managing dependencies that can be
+  # automatically injected into route handlers.
+  #
+  # @example Registering a value dependency
+  #   app.provide("database_url", "postgresql://localhost/mydb")
+  #
+  # @example Registering a factory dependency
+  #   app.provide("db_pool", depends_on: ["database_url"]) do |database_url:|
+  #     ConnectionPool.new(database_url)
+  #   end
+  #
+  # @example Singleton dependency (shared across all requests)
+  #   app.provide("config", singleton: true) do
+  #     Config.load_from_file("config.yml")
+  #   end
+  #
+  # @example Using Provide wrapper
+  #   app.provide("db", Spikard::Provide.new(method("create_db"), cacheable: true))
+  module ProvideSupport
+    # Register a dependency in the DI container
+    #
+    # This method supports three patterns:
+    # 1. **Value dependency**: Pass a value directly (e.g., string, number, object)
+    # 2. **Factory dependency**: Pass a block that computes the value
+    # 3. **Provide wrapper**: Pass a Spikard::Provide instance
+    #
+    # @param key [String, Symbol] Unique identifier for the dependency
+    # @param value [Object, Provide, nil] Static value, Provide instance, or nil
+    # @param depends_on [Array<String, Symbol>] List of dependency keys this factory depends on
+    # @param singleton [Boolean] Whether to cache the value globally (default: false)
+    # @param cacheable [Boolean] Whether to cache the value per-request (default: true)
+    # @yield Optional factory block that receives dependencies as keyword arguments
+    # @yieldparam **deps [Hash] Resolved dependencies as keyword arguments
+    # @yieldreturn [Object] The computed dependency value
+    # @return [self] Returns self for method chaining
+    #
+    # @example Value dependency
+    #   app.provide("app_name", "MyApp")
+    #   app.provide("port", 8080)
+    #
+    # @example Factory with dependencies
+    #   app.provide("database", depends_on: ["config"]) do |config:|
+    #     Database.connect(config["db_url"])
+    #   end
+    #
+    # @example Singleton factory
+    #   app.provide("thread_pool", singleton: true) do
+    #     ThreadPool.new(size: 10)
+    #   end
+    #
+    # @example Non-cacheable factory (resolves every time)
+    #   app.provide("request_id", cacheable: false) do
+    #     SecureRandom.uuid
+    #   end
+    #
+    # @example Using Provide wrapper
+    #   app.provide("db", Spikard::Provide.new(method("create_db"), cacheable: true))
+    # rubocop:disable Metrics/MethodLength
+    def provide(key, value = nil, depends_on: [], singleton: false, cacheable: true, &block)
+      key_str = key.to_s
+      @dependencies ||= {}
+
+      # Handle Provide wrapper instances
+      if value.is_a?(Provide)
+        provider = value
+        @dependencies[key_str] = {
+          type: :factory,
+          factory: provider.factory,
+          depends_on: provider.depends_on,
+          singleton: provider.singleton,
+          cacheable: provider.cacheable
+        }
+      elsif block
+        # Factory dependency (block form)
+        @dependencies[key_str] = {
+          type: :factory,
+          factory: block,
+          depends_on: Array(depends_on).map(&:to_s),
+          singleton: singleton,
+          cacheable: cacheable
+        }
+      else
+        # Value dependency
+        raise ArgumentError, 'Either provide a value or a block, not both' if value.nil?
+
+        @dependencies[key_str] = {
+          type: :value,
+          value: value,
+          singleton: true, # Values are always singleton
+          cacheable: true
+        }
+      end
+
+      self
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Get all registered dependencies
+    #
+    # @return [Hash] Dictionary mapping dependency keys to their definitions
+    # @api private
+    def dependencies
+      @dependencies ||= {}
+      @dependencies.dup
+    end
+  end
+
+  # Dependency injection handler wrapper
+  #
+  # Wraps a route handler to inject dependencies based on parameter names.
+  # Dependencies are resolved from the DI container and passed as keyword arguments.
+  #
+  # @api private
+  module DIHandlerWrapper
+    # Wrap a handler to inject dependencies
+    #
+    # @param handler [Proc] The original route handler
+    # @param dependencies [Hash] Available dependencies from the app
+    # @return [Proc] Wrapped handler with DI support
+    # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    def self.wrap_handler(handler, dependencies)
+      # Extract parameter names from the handler
+      params = handler.parameters.map { |_type, name| name.to_s }
+
+      # Find which parameters match registered dependencies
+      injectable_params = params & dependencies.keys
+
+      if injectable_params.empty?
+        # No DI needed, return original handler
+        return handler
+      end
+
+      # Create wrapped handler that injects dependencies
+      lambda do |request|
+        # Build kwargs with injected dependencies
+        kwargs = {}
+
+        injectable_params.each do |param_name|
+          dep_def = dependencies[param_name]
+          kwargs[param_name.to_sym] = resolve_dependency(dep_def, request)
+        end
+
+        # Call original handler with injected dependencies
+        if handler.arity.zero?
+          # Handler takes no arguments (dependencies injected via closure or instance vars)
+          handler.call
+        elsif injectable_params.length == params.length
+          # All parameters are dependencies
+          handler.call(**kwargs)
+        else
+          # Mix of request data and dependencies
+          handler.call(request, **kwargs)
+        end
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+    # Resolve a dependency definition
+    #
+    # @param dep_def [Hash] Dependency definition
+    # @param request [Hash] Request context (unused for now, future: per-request deps)
+    # @return [Object] Resolved dependency value
+    # @api private
+    def self.resolve_dependency(dep_def, _request)
+      case dep_def[:type]
+      when :value
+        dep_def[:value]
+      when :factory
+        factory = dep_def[:factory]
+        dep_def[:depends_on]
+        # TODO: Implement nested dependency resolution when dependencies are provided
+        factory.call
+      end
+    end
+  end
+end

data/lib/spikard/testing.rb

@@ -24,7 +24,8 @@ module Spikard
       handlers = app.handler_map.transform_keys(&:to_sym)
       ws_handlers = app.websocket_handlers || {}
       sse_producers = app.sse_producers || {}
-      native = Spikard::Native::TestClient.new(routes_json, handlers, config, ws_handlers, sse_producers)
+      dependencies = app.dependencies || {}
+      native = Spikard::Native::TestClient.new(routes_json, handlers, config, ws_handlers, sse_producers, dependencies)
       TestClient.new(native)
     end
 

data/lib/spikard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spikard
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/spikard.rb

@@ -20,6 +20,7 @@ require_relative 'spikard/websocket'
 require_relative 'spikard/sse'
 require_relative 'spikard/upload_file'
 require_relative 'spikard/converters'
+require_relative 'spikard/provide'
 require_relative 'spikard/handler_wrapper'
 require_relative 'spikard/app'
 require_relative 'spikard/testing'

data/sig/spikard.rbs

@@ -187,8 +187,20 @@ module Spikard
     def lifecycle_hooks: () -> Hash[Symbol, Array[Proc]]
   end
 
+  module ProvideSupport
+    def provide: (
+      String | Symbol,
+      ?untyped,
+      ?depends_on: Array[String | Symbol],
+      ?singleton: bool,
+      ?cacheable: bool
+    ) ?{ (**untyped) -> untyped } -> self
+    def dependencies: () -> Hash[String, untyped]
+  end
+
   class App
     include LifecycleHooks
+    include ProvideSupport
 
     attr_reader routes: Array[untyped]
 
@@ -242,7 +254,8 @@ module Spikard
       ServerConfig,
       Hash[Symbol, Array[Proc]],
       Hash[String, Proc],
-      Hash[String, Proc]
+      Hash[String, Proc],
+      Hash[String, untyped]
     ) -> void
 
     class TestClient

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spikard
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Na'aman Hirschfeld
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-23 00:00:00.000000000 Z
+date: 2025-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-client-simple
@@ -25,8 +25,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0.8'
 description: |
-  Spikard provides a high-performance HTTP toolkit with a Rust core and thin language bindings.
-  This gem bundles the Ruby bridge implemented with Magnus.
+  Spikard is a Rust-centric multi-language HTTP toolkit providing a high-performance core library
+  and language bindings (Python, Node.js, Ruby, PHP, WebAssembly) to build and validate typed web services.
+
+  The Ruby binding uses Magnus for zero-overhead FFI, providing Sinatra-style routing, full async/await support,
+  WebSockets, Server-Sent Events, request validation with JSON Schema and dry-schema, lifecycle hooks,
+  dependency injection, and comprehensive middleware stack (compression, rate limiting, authentication).
+
+  Features:
+  - Zero-copy Rust-to-Ruby serialization via Magnus
+  - Async-first with Tokio and Axum backing
+  - Type-safe RBS type definitions for Steep
+  - Tower-HTTP middleware stack
+  - Lifecycle hooks (onRequest, preValidation, preHandler, onResponse, onError)
+  - Built-in WebSocket and SSE support
+  - Request validation with JSON Schema
 email:
 - nhirschfeld@gmail.com
 executables: []
@@ -45,6 +58,7 @@ files:
 - lib/spikard/config.rb
 - lib/spikard/converters.rb
 - lib/spikard/handler_wrapper.rb
+- lib/spikard/provide.rb
 - lib/spikard/response.rb
 - lib/spikard/schema.rb
 - lib/spikard/sse.rb
@@ -61,6 +75,9 @@ metadata:
   homepage_uri: https://github.com/Goldziher/spikard
   source_code_uri: https://github.com/Goldziher/spikard
   changelog_uri: https://github.com/Goldziher/spikard/blob/main/CHANGELOG.md
+  documentation_uri: https://github.com/Goldziher/spikard/tree/main/packages/ruby#documentation
+  bug_tracker_uri: https://github.com/Goldziher/spikard/issues
+  funding_uri: https://github.com/Goldziher/spikard
   rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
@@ -80,5 +97,5 @@ requirements: []
 rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
-summary: Ruby bindings for the Spikard HTTP toolkit
+summary: High-performance HTTP toolkit with Rust core and Ruby bindings
 test_files: []