# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "containable/builder"
          
        
      
        

          

            
              1
            

            
              
            

            require "containable/register"
          
        
      
        

          

            
              1
            

            
              
            

            require "containable/resolver"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # Main namespace.
          
        
      
        

          

            
              1
            

            
              
            

            module Containable
          
        
      
        

          

            
              1
            

            
              
            

              def self.extended descendant
          
        
      
        

          

            
              71
            

            
              
            

                super
          
        
      
        

          

            
              71
            

            
              
            

                descendant.extend Builder.new
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

              def self.[](register: Register, resolver: Resolver) = Builder.new(register:, resolver:)
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "concurrent/hash"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Containable
          
        
      
        

          

            

            
              
            

              # Provides safe registration and resolution of dependencies.
          
        
      
        

          

            
              1
            

            
              
            

              class Builder < Module
          
        
      
        

          

            
              1
            

            
              
            

                def initialize dependencies = Concurrent::Hash.new, register: Register, resolver: Resolver
          
        
      
        

          

            
              219
            

            
              
            

                  super()
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              219
            

            
              
            

                  @dependencies = dependencies
          
        
      
        

          

            
              219
            

            
              
            

                  @register = register.new dependencies
          
        
      
        

          

            
              219
            

            
              
            

                  @resolver = resolver.new dependencies
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              3504
            

            
              
            

                  private_methods.grep(/\A(define)_/).sort.each { |method| __send__ method }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              219
            

            
              
            

                  alias_method :[]=, :register
          
        
      
        

          

            
              219
            

            
              
            

                  alias_method :[], :resolve
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              219
            

            
              
            

                  freeze
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def extended descendant
          
        
      
        

          

            
              218
            

            
              
                
                  then: 3
                
              
                
                  else: 215
                
              
            

                  fail TypeError, "Only a module can be a container." if descendant.is_a? Class
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              215
            

            
              
            

                  super
          
        
      
        

          

            
              1
            

            
              
            

                  descendant.class_eval "private_class_method :dependencies", __FILE__, __LINE__
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :dependencies, :register, :resolver
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_dependencies target = dependencies
          
        
      
        

          

            
              558
            

            
              
            

                  define_method(:dependencies) { target }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_register target = register
          
        
      
        

          

            
              219
            

            
              
            

                  define_method :register do |key, value = nil, as: :cache, &block|
          
        
      
        

          

            
              205
            

            
              
                
                  then: 9
                
              
                
                  else: 196
                
              
            

                    fail FrozenError, "Can't modify frozen container." if dependencies.frozen?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              196
            

            
              
            

                    target.call key, value, as:, &block
          
        
      
        

          

            
              190
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_merge target: register
          
        
      
        

          

            
              219
            

            
              
            

                  define_method :merge do |other, *keys, namespace: nil, as: :cache|
          
        
      
        

          

            
              6
            

            
              
            

                    target.merge(other, *keys, namespace:, as:)
          
        
      
        

          

            
              6
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_namespace target = register
          
        
      
        

          

            
              219
            

            
              
            

                  define_method :namespace do |name, &block|
          
        
      
        

          

            
              15
            

            
              
            

                    target.namespace name, &block
          
        
      
        

          

            
              15
            

            
              
            

                    self
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_resolve target = resolver
          
        
      
        

          

            
              297
            

            
              
            

                  define_method(:resolve) { |key| target.call key }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_each target = dependencies
          
        
      
        

          

            
              247
            

            
              
            

                  define_method(:each) { |&block| target.transform_values(&:first).each(&block) }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_each_key target = dependencies
          
        
      
        

          

            
              225
            

            
              
            

                  define_method(:each_key) { |&block| target.each_key(&block) }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_key? target = dependencies
          
        
      
        

          

            
              293
            

            
              
            

                  define_method(:key?) { |name| target.key? name }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_keys target = dependencies
          
        
      
        

          

            
              225
            

            
              
            

                  define_method(:keys) { target.keys }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_clone
          
        
      
        

          

            
              219
            

            
              
            

                  define_method :clone do
          
        
      
        

          

            
              24
            

            
              
                
                  then: 3
                
              
                
                  else: 9
                
              
            

                    dup.tap { |duplicate| duplicate.freeze if dependencies.frozen? }
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_dup target = self.class,
          
        
      
        

          

            

            
              
            

                               local_register: register.class,
          
        
      
        

          

            

            
              
            

                               local_resolver: resolver.class
          
        
      
        

          

            
              219
            

            
              
            

                  define_method :dup do
          
        
      
        

          

            
              24
            

            
              
            

                    instance = target.new dependencies.dup, register: local_register, resolver: local_resolver
          
        
      
        

          

            
              24
            

            
              
            

                    Module.new.set_temporary_name("containable").extend instance
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_freeze
          
        
      
        

          

            
              243
            

            
              
            

                  define_method(:freeze) { dependencies.freeze and self }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_frozen?
          
        
      
        

          

            
              234
            

            
              
            

                  define_method(:frozen?) { dependencies.frozen? }
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_stub
          
        
      
        

          

            
              219
            

            
              
            

                  define_method :stub! do |**keywords|
          
        
      
        

          

            
              36
            

            
              
            

                    require "containable/test"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              36
            

            
              
            

                    extend Test
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              36
            

            
              
            

                    stub(**keywords)
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              4
            

            
              
            

                def define_restore = define_method(:restore) { false }
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "concurrent/hash"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Containable
          
        
      
        

          

            

            
              
            

              # :reek:TooManyInstanceVariables
          
        
      
        

          

            

            
              
            

              # Registers dependencies for future evaluation.
          
        
      
        

          

            
              1
            

            
              
            

              class Register
          
        
      
        

          

            
              1
            

            
              
            

                SEPARATOR = "."
          
        
      
        

          

            
              1
            

            
              
            

                DIRECTIVES = %i[cache fresh].freeze
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize dependencies = Concurrent::Hash.new, separator: SEPARATOR, directives: DIRECTIVES
          
        
      
        

          

            
              237
            

            
              
            

                  @dependencies = dependencies
          
        
      
        

          

            
              237
            

            
              
            

                  @separator = separator
          
        
      
        

          

            
              237
            

            
              
            

                  @directives = directives
          
        
      
        

          

            
              237
            

            
              
            

                  @keys = []
          
        
      
        

          

            
              237
            

            
              
            

                  @depth = 0
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def call key, value = nil, as: :cache, &block
          
        
      
        

          

            
              236
            

            
              
                
                  then: 1
                
              
                
                  else: 235
                
              
            

                  warn "Registration of value is ignored since block takes precedence." if value && block
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              236
            

            
              
            

                  namespaced_key = namespacify key
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              236
            

            
              
            

                  check_duplicate key, namespaced_key
          
        
      
        

          

            
              229
            

            
              
            

                  check_directive as
          
        
      
        

          

            
              228
            

            
              
            

                  dependencies[namespaced_key] = [block || value, as]
          
        
      
        

          

            
              228
            

            
              
            

                  self
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                alias register call
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def merge other, *keys, namespace: nil, as: :cache
          
        
      
        

          

            
              26
            

            
              
            

                  keys.each { call [namespace, it].compact.join("."), other[it], as: }
          
        
      
        

          

            
              11
            

            
              
            

                  self
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def namespace(name, &)
          
        
      
        

          

            
              36
            

            
              
                
                  then: 20
                
              
                
                  else: 16
                
              
            

                  keys.clear if depth.zero?
          
        
      
        

          

            
              36
            

            
              
            

                  keys.append name
          
        
      
        

          

            
              36
            

            
              
            

                  visit(&)
          
        
      
        

          

            
              36
            

            
              
            

                  self
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                protected
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :dependencies, :separator, :directives
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_accessor :keys, :depth
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def namespacify(key) = keys[..depth].append(key).join separator
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def check_duplicate key, namespaced_key
          
        
      
        

          

            
              236
            

            
              
            

                  message = "Dependency is already registered: #{key.inspect}."
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              236
            

            
              
                
                  then: 7
                
              
                
                  else: 229
                
              
            

                  fail KeyError, message if dependencies.key? namespaced_key
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def check_directive value
          
        
      
        

          

            
              229
            

            
              
                
                  then: 228
                
              
                
                  else: 1
                
              
            

                  return if directives.include? value
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                  fail ArgumentError,
          
        
      
        

          

            

            
              
            

                       %(Invalid directive: #{value.inspect}. Use #{directives.map(&:inspect).join " or "}.)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def visit &block
          
        
      
        

          

            
              36
            

            
              
            

                  increment
          
        
      
        

          

            
              36
            

            
              
                
                  then: 28
                
              
                
                  else: 8
                
              
            

                  instance_eval(&block) if block
          
        
      
        

          

            
              36
            

            
              
            

                  keys.pop
          
        
      
        

          

            
              36
            

            
              
            

                  decrement
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def increment = self.depth += 1
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def decrement = self.depth -= 1
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "concurrent/hash"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Containable
          
        
      
        

          

            

            
              
            

              # Resolves previously registered dependencies.
          
        
      
        

          

            
              1
            

            
              
            

              class Resolver
          
        
      
        

          

            
              1
            

            
              
            

                def initialize dependencies = Concurrent::Hash.new
          
        
      
        

          

            
              227
            

            
              
            

                  @dependencies = dependencies
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def call key
          
        
      
        

          

            
              87
            

            
              
            

                  tuple = fetch key
          
        
      
        

          

            
              79
            

            
              
            

                  value, as = tuple
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              79
            

            
              
                
                  else: 45
                
              
                
                  then: 34
                
              
            

                  return value unless value.is_a?(Proc) && value.arity.zero?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              45
            

            
              
            

                  process key, value, as
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                protected
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :dependencies
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def fetch key
          
        
      
        

          

            
              87
            

            
              
            

                  dependencies.fetch key.to_s do
          
        
      
        

          

            
              8
            

            
              
            

                    fail KeyError, "Unable to resolve dependency: #{key.inspect}."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def process key, closure, directive
          
        
      
        

          

            
              45
            

            
              
            

                  value = closure.call
          
        
      
        

          

            
              45
            

            
              
                
                  then: 43
                
              
                
                  else: 2
                
              
            

                  dependencies[key.to_s] = [value, directive] if directive == :cache
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              45
            

            
              
            

                  value
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Containable
          
        
      
        

          

            

            
              
            

              # Allows stubbing of dependencies for testing purposes only.
          
        
      
        

          

            
              1
            

            
              
            

              module Test
          
        
      
        

          

            
              13
            

            
              
            

                def resolve(key) = stubs.fetch(key.to_s) { super }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                alias [] resolve
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def stub(**overrides)
          
        
      
        

          

            
              68
            

            
              
            

                  @originals ||= dependencies.dup
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              68
            

            
              
            

                  overrides.each do |key, value|
          
        
      
        

          

            
              68
            

            
              
            

                    normalized_key = key.to_s
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              68
            

            
              
                
                  else: 64
                
              
                
                  then: 4
                
              
            

                    fail KeyError, "Unable to stub unknown key: #{key.inspect}." unless key? normalized_key
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              64
            

            
              
            

                    stubs[normalized_key] = value
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def stub!(**) = stub(**)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def restore
          
        
      
        

          

            
              16
            

            
              
            

                  stubs.clear
          
        
      
        

          

            
              16
            

            
              
                
                  then: 15
                
              
                
                  else: 1
                
              
            

                  dependencies.replace originals if originals
          
        
      
        

          

            
              16
            

            
              
            

                  true
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def originals = @originals
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def stubs = @stubs ||= {}
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end