# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "infusible/actuator"
          
        
      
        

          

            
              1
            

            
              
            

            require "infusible/builder"
          
        
      
        

          

            
              1
            

            
              
            

            require "infusible/dependency_map"
          
        
      
        

          

            
              1
            

            
              
            

            require "infusible/errors/duplicate_dependency"
          
        
      
        

          

            
              1
            

            
              
            

            require "infusible/errors/invalid_dependency"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # Main namespace.
          
        
      
        

          

            
              1
            

            
              
            

            module Infusible
          
        
      
        

          

            
              1
            

            
              
            

              METHOD_SCOPES = %i[public protected private].freeze
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

              def self.[](container) = Actuator.new container
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Infusible
          
        
      
        

          

            

            
              
            

              # Associates the container with the builder for actualization.
          
        
      
        

          

            
              1
            

            
              
            

              class Actuator
          
        
      
        

          

            
              1
            

            
              
            

                def initialize container, builder: Infusible::Builder
          
        
      
        

          

            
              8
            

            
              
            

                  @container = container
          
        
      
        

          

            
              8
            

            
              
            

                  @builder = builder
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def [](*configuration) = builder.new container, *configuration
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def public(*configuration) = builder.new container, *configuration, scope: __method__
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def protected(*configuration) = builder.new container, *configuration, scope: __method__
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :container, :builder
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "marameters"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Infusible
          
        
      
        

          

            

            
              
            

              # Provides the automatic and complete resolution of all injected dependencies.
          
        
      
        

          

            

            
              
            

              # :reek:TooManyInstanceVariables
          
        
      
        

          

            
              1
            

            
              
            

              class Builder < Module
          
        
      
        

          

            
              1
            

            
              
            

                def self.define_instance_variables target, keys, keywords
          
        
      
        

          

            
              41
            

            
              
                
                  else: 4
                
              
                
                  then: 37
                
              
            

                  unless target.instance_variable_defined? :@infused_keys
          
        
      
        

          

            
              37
            

            
              
            

                    target.instance_variable_set :@infused_keys, keys
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              41
            

            
              
            

                  keys.each do |key|
          
        
      
        

          

            
              72
            

            
              
                
                  else: 70
                
              
                
                  then: 2
                
              
            

                    next unless keywords.key?(key) || !target.instance_variable_defined?(:"@#{key}")
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              70
            

            
              
            

                    target.instance_variable_set :"@#{key}", keywords[key]
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private_class_method :define_instance_variables
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize container, *configuration, scope: :private
          
        
      
        

          

            
              61
            

            
              
            

                  super()
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              61
            

            
              
            

                  @container = container
          
        
      
        

          

            
              61
            

            
              
            

                  @dependencies = DependencyMap.new(*configuration)
          
        
      
        

          

            
              61
            

            
              
            

                  @scope = scope
          
        
      
        

          

            
              61
            

            
              
            

                  @class_module = Module.new
          
        
      
        

          

            
              61
            

            
              
            

                  @instance_module = Module.new.set_temporary_name "infusible"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              61
            

            
              
            

                  freeze
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def included descendant
          
        
      
        

          

            
              43
            

            
              
                
                  else: 42
                
              
                
                  then: 1
                
              
            

                  unless descendant.is_a? Class
          
        
      
        

          

            
              1
            

            
              
            

                    fail TypeError,
          
        
      
        

          

            

            
              
            

                         "Can only infuse a class, invalid object: #{descendant} (#{descendant.class})."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              42
            

            
              
            

                  super
          
        
      
        

          

            
              42
            

            
              
            

                  define descendant
          
        
      
        

          

            
              42
            

            
              
            

                  descendant.extend class_module
          
        
      
        

          

            
              42
            

            
              
            

                  descendant.include instance_module
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :container, :dependencies, :scope, :class_module, :instance_module
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define descendant
          
        
      
        

          

            
              42
            

            
              
            

                  define_new
          
        
      
        

          

            
              42
            

            
              
            

                  define_initialize descendant
          
        
      
        

          

            
              42
            

            
              
            

                  define_readers
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_new
          
        
      
        

          

            
              42
            

            
              
            

                  class_module.module_exec container, dependencies.to_h do |container, collection|
          
        
      
        

          

            
              42
            

            
              
            

                    define_method :new do |*positionals, **keywords, &block|
          
        
      
        

          

            
              113
            

            
              
                
                  else: 4
                
              
                
                  then: 68
                
              
            

                      collection.each { |name, id| keywords[name] = container[id] unless keywords.key? name }
          
        
      
        

          

            
              41
            

            
              
            

                      super(*positionals, **keywords, &block)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_initialize descendant
          
        
      
        

          

            
              42
            

            
              
            

                  super_parameters = Marameters.of(descendant, :initialize).map do |instance|
          
        
      
        

          

            
              45
            

            
              
                
                  else: 3
                
              
                
                  then: 42
                
              
            

                    break instance unless instance.only_bare_splats?
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              42
            

            
              
            

                  variablizer = self.class.method :define_instance_variables
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              42
            

            
              
                
                  then: 3
                
              
            

                  if super_parameters.positionals? || super_parameters.only_single_splats?
          
        
      
        

          

            
              3
            

            
              
            

                    define_initialize_with_positionals super_parameters, variablizer
          
        
      
        

          

            

            
              
                
                  else: 39
                
              
            

                  else
          
        
      
        

          

            
              39
            

            
              
            

                    define_initialize_with_keywords super_parameters, variablizer
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_initialize_with_positionals super_parameters, variablizer
          
        
      
        

          

            
              3
            

            
              
            

                  instance_module.module_exec dependencies.keys, variablizer do |keys, definer|
          
        
      
        

          

            
              3
            

            
              
            

                    define_method :initialize do |*positionals, **keywords, &block|
          
        
      
        

          

            
              3
            

            
              
            

                      definer.call self, keys, keywords
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              3
            

            
              
                
                  then: 1
                
              
            

                      if super_parameters.only_single_splats?
          
        
      
        

          

            
              1
            

            
              
            

                        super(*positionals, **keywords, &block)
          
        
      
        

          

            

            
              
                
                  else: 2
                
              
            

                      else
          
        
      
        

          

            
              2
            

            
              
            

                        super(*positionals, **super_parameters.keywords_for(*keys, **keywords), &block)
          
        
      
        

          

            

            
              
            

                      end
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_initialize_with_keywords super_parameters, variablizer
          
        
      
        

          

            
              39
            

            
              
            

                  instance_module.module_exec dependencies.keys, variablizer do |keys, definer|
          
        
      
        

          

            
              39
            

            
              
            

                    define_method :initialize do |**keywords, &block|
          
        
      
        

          

            
              38
            

            
              
            

                      definer.call self, keys, keywords
          
        
      
        

          

            
              38
            

            
              
            

                      super(**super_parameters.keywords_for(*keys, **keywords), &block)
          
        
      
        

          

            

            
              
            

                    end
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def define_readers
          
        
      
        

          

            
              116
            

            
              
            

                  methods = dependencies.keys.map { |key| ":#{key}" }
          
        
      
        

          

            
              42
            

            
              
                
                  then: 41
                
              
                
                  else: 1
                
              
            

                  computed_scope = METHOD_SCOPES.include?(scope) ? scope : :private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              42
            

            
              
            

                  instance_module.module_eval <<-READERS, __FILE__, __LINE__ + 1
          
        
      
        

          

            
              1
            

            
              
            

                    attr_reader :infused_keys
          
        
      
        

          

            
              1
            

            
              
            

                    #{computed_scope} attr_reader #{methods.join ", "}
          
        
      
        

          

            

            
              
            

                  READERS
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Infusible
          
        
      
        

          

            

            
              
            

              # Sanitizes and resolves dependencies for use.
          
        
      
        

          

            
              1
            

            
              
            

              class DependencyMap
          
        
      
        

          

            
              1
            

            
              
            

                PATTERNS = {key: /([a-z_][a-zA-Z_0-9]*)$/, valid: /^[\w.]+$/}.freeze
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :keys
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def initialize *configuration, patterns: PATTERNS
          
        
      
        

          

            
              75
            

            
              
            

                  @patterns = patterns
          
        
      
        

          

            
              75
            

            
              
            

                  @collection = {}
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              75
            

            
              
                
                  then: 8
                
              
                
                  else: 67
                
              
            

                  aliases = configuration.last.is_a?(Hash) ? configuration.pop : {}
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              208
            

            
              
            

                  configuration.each { |identifier| add to_key(identifier), identifier }
          
        
      
        

          

            
              79
            

            
              
            

                  aliases.each { |key, identifier| add key, identifier }
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              68
            

            
              
            

                  @keys = collection.keys.freeze
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def to_h = collection
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                private
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                attr_reader :patterns, :collection
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def to_key identifier
          
        
      
        

          

            
              133
            

            
              
            

                  key = identifier[patterns.fetch(:key)]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              133
            

            
              
                
                  then: 131
                
              
                
                  else: 2
                
              
            

                  return key if key && key.match?(patterns.fetch(:valid))
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

                  fail Errors::InvalidDependency.new(identifier:)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

                def add key, identifier
          
        
      
        

          

            
              140
            

            
              
            

                  key = key.to_sym
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              140
            

            
              
                
                  else: 5
                
              
                
                  then: 135
                
              
            

                  return collection[key] = identifier unless collection.key? key
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              5
            

            
              
            

                  fail Errors::DuplicateDependency.new(key:, identifier:)
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Infusible
          
        
      
        

          

            
              1
            

            
              
            

              module Errors
          
        
      
        

          

            

            
              
            

                # Prevents duplicate dependencies from being injected.
          
        
      
        

          

            
              1
            

            
              
            

                class DuplicateDependency < StandardError
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize key:, identifier:
          
        
      
        

          

            
              6
            

            
              
            

                    super "Remove #{identifier.inspect} since it's a duplicate of #{key.inspect}."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Infusible
          
        
      
        

          

            
              1
            

            
              
            

              module Errors
          
        
      
        

          

            

            
              
            

                # Prevents improperly named dependencies from being injected.
          
        
      
        

          

            
              1
            

            
              
            

                class InvalidDependency < StandardError
          
        
      
        

          

            
              1
            

            
              
            

                  def initialize identifier:
          
        
      
        

          

            
              3
            

            
              
            

                    super "Cannot use #{identifier.inspect} as an identifier."
          
        
      
        

          

            

            
              
            

                  end
          
        
      
        

          

            

            
              
            

                end
          
        
      
        

          

            

            
              
            

              end
          
        
      
        

          

            

            
              
            

            end