Module: Spikard::DIHandlerWrapper Private

Defined in:

lib/spikard/provide.rb

Overview

This module is part of a private API. You should avoid using this module if possible, as it may be removed or be changed in the future.

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.

Class Method Summary

• .resolve_dependency(dep_def, _request) ⇒ Object private

  Resolve a dependency definition.

• .wrap_handler(handler, dependencies) ⇒ Proc private

  Wrap a handler to inject dependencies.

Class Method Details

.resolve_dependency(dep_def, _request) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Resolve a dependency definition

Parameters:

• dep_def (Hash) —

  Dependency definition

• request (Hash) —

  Request context (unused for now, future: per-request deps)

Returns:

• (Object) —

  Resolved dependency value

# File 'lib/spikard/provide.rb', line 216

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

.wrap_handler(handler, dependencies) ⇒ Proc

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Wrap a handler to inject dependencies

rubocop:disable Metrics/AbcSize, Metrics/MethodLength

Parameters:

• handler (Proc) —

  The original route handler

• dependencies (Hash) —

  Available dependencies from the app

Returns:

• (Proc) —

  Wrapped handler with DI support

# File 'lib/spikard/provide.rb', line 173

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