class Codependent::Resolvers::RootResolver

Attributes

injectables[R]

Public Class Methods

new(injectables) click to toggle source
# File lib/codependent/resolvers/root_resolver.rb, line 6
def initialize(injectables)
  @injectables = injectables
end

Public Instance Methods

resolve(id) click to toggle source
# File lib/codependent/resolvers/root_resolver.rb, line 12
def resolve(id)
  dependencies = build_dependency_graph(id)

  resolved = resolve_eager_dependencies(dependencies)
  resolve_deferred_dependencies!(resolved)

  resolved[id]
end

Private Instance Methods

build_dependency_graph(id) click to toggle source
# File lib/codependent/resolvers/root_resolver.rb, line 67
def build_dependency_graph(id)
  stack = [id]
  dependencies = [id]

  until stack.empty?
    current = injectables[stack.pop]

    current.dependencies.each do |dep_id|
      stack.push(dep_id) unless dependencies.include?(dep_id)
      dependencies.unshift(dep_id)
    end
  end

  dependencies
end
deferred?(injectable) click to toggle source
# File lib/codependent/resolvers/root_resolver.rb, line 23
def deferred?(injectable)
  injectable.resolver == DeferredTypeResolver
end
required_dependencies(all_dependencies, injectable) click to toggle source
# File lib/codependent/resolvers/root_resolver.rb, line 63
def required_dependencies(all_dependencies, injectable)
  all_dependencies.select { |k, _| injectable.dependencies.include?(k) }
end
resolve_deferred_dependencies!(available_dependencies) click to toggle source
# File lib/codependent/resolvers/root_resolver.rb, line 34
def resolve_deferred_dependencies!(available_dependencies)
  available_dependencies.keys.each do |id|
    injectable = injectables[id]

    next unless deferred?(injectable)

    resolver = injectable.resolver.new

    resolver.apply(
      available_dependencies[id],
      required_dependencies(available_dependencies, injectable)
    )
  end
end
resolve_eager_dependencies(injectable_ids) click to toggle source
# File lib/codependent/resolvers/root_resolver.rb, line 27
def resolve_eager_dependencies(injectable_ids)
  injectable_ids.reduce({}) do |acc, id|
    next acc if acc.key?(id)
    acc.tap { |hash| hash[id] = resolve_value(id, acc) }
  end
end
resolve_value(id, available_dependencies) click to toggle source
# File lib/codependent/resolvers/root_resolver.rb, line 49
def resolve_value(id, available_dependencies)
  injectable = injectables[id]
  dependencies = {}

  unless deferred?(injectable)
    dependencies = required_dependencies(
      available_dependencies,
      injectable
    )
  end

  injectable.value(dependencies)
end