aux 0.0.9 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f14a4137dfae54717b5c16ff83449ee58daabf5e1be565b777a9f82d297769d4
-  data.tar.gz: ee6540f4deafd067569aeb755789a533f20e95298639692f0c812289bd3a2366
+  metadata.gz: f7ab27a48b02884baff3dedd1a770d02a71be57471b40aaabfd1213068dfd317
+  data.tar.gz: 1e38945b37770dc63d2280c1b000cff18b96d06b6544430480c815ab571213ac
 SHA512:
-  metadata.gz: f30194532d6aa7016d3c8706c64a0c3c00375a786e628b95df8903bc1419ca3be99321155a15304c3864bd73c4722bc0e0f1f8403cf73187c1eeee4add48c1be
-  data.tar.gz: 6f1474fcee6e6c56be8c0a59b7833b0deffca0a926702b240ecb3ef2534c2951d0b81bf5fe266d194764baefea6f8f415815660530f03f3ecfdc8ccaf6f9f947
+  metadata.gz: 05c2d14e99306c482ca584ca330e0808e653bab12082c5726dfd8495370f1109646afa0a7985c948d180715ce4aa074d4c0eb9cb8f58d409dab30305fb2fcdc3
+  data.tar.gz: 116352323a5886ac2e2c8eeafe0a55687bd5e6e37d29e4eb66b4b4c76eb7ad5e7ba5eefbdaec0a7c25cc6afe77318713cef01fcab95aeee957dbc3726b15c986

data/aux.gemspec

@@ -11,8 +11,9 @@ Gem::Specification.new do |specification|
   specification.homepage = 'https://github.com/eboyko/aux'
 
   specification.add_dependency 'activemodel', '>= 6.1', '< 8'
+  specification.add_dependency 'dry-container', '>= 0.9.0', '<= 0.11'
 
-  specification.add_development_dependency 'dry-container', '~> 0.11.0'
+  specification.add_development_dependency 'zeitwerk', '~> 2.5'
   specification.add_development_dependency 'rubocop', '~> 1.36.0'
 
   specification.required_ruby_version = '>= 2.7.1'

data/lib/aux/pluggable/class_methods.rb

@@ -4,73 +4,73 @@ module Aux
   module Pluggable
     # Describes methods that would be inherited by pluggable classes
     module ClassMethods
-      # @param dependencies [Hash{Symbol => Object}]
-      def new(**dependencies)
+      # Create a new instance of the class that includes the Pluggable module
+      # @param positional_arguments [Array<Object>]
+      # @param keyword_arguments [Hash{Symbol => Object}]
+      # @return [Object]
+      #
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def new(*positional_arguments, **keyword_arguments)
         instance = allocate
 
+        # Configure some local variables for shorter calls
+        # @type [Aux::Pluggable::Connector]
+        pluggable = instance.class.instance_variable_get(:@_pluggable)
+        dependencies_keys = pluggable.dependencies.map(&:pointer)
+
         # Configure dependencies that come from the registry
-        @_dependencies.each do |name, dependency|
-          instance.instance_variable_set("@#{name}", dependency)
+        pluggable.dependencies.each do |dependency|
+          instance.instance_variable_set("@#{dependency.pointer}", dependency.target)
+
+          # The next lines are required to make resolved dependencies available
+          # by its reader methods within customized initialization
+          #
+          # TODO: Discuss whether this is appropriate behaviour
+          next if instance.respond_to?(dependency.pointer, true)
+
+          define_method(dependency.pointer) { instance_variable_get("@#{dependency.pointer}") }
+          next unless dependency.private
+
+          private(dependency.pointer)
         end
 
         # Configure dependencies that come from the customized initialization procedure
-        dependencies.each do |name, dependency|
-          instance.instance_variable_set("@#{name}", dependency) if @_dependencies.include?(name)
+        dependencies_overrides = keyword_arguments.slice(*dependencies_keys)
+        dependencies_overrides.each do |pointer, target|
+          instance.instance_variable_set("@#{pointer}", target)
         end
 
+        # Run the origin's initialization procedure if any other arguments given
+        additional_keyword_arguments = keyword_arguments.reject { |key, _value| dependencies_keys.include?(key) }
+
+        # TODO: Consider checks like positional_arguments.any? or additional_keyword_arguments.any?
+        instance.send(:initialize, *positional_arguments, **additional_keyword_arguments)
+
         instance
       end
-
-      private
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
       # @param initialize [TrueClass, FalseClass]
       # @param memoize [TrueClass, FalseClass]
       # @param scope [TrueClass, Symbol, String, nil]
       # @param as [Symbol, String, nil]
       def register(initialize: false, memoize: false, scope: true, as: nil)
-        dependency_cipher = Utilities.dependency_cipher(name, scope: scope, code: as)
-        @_registry.register(dependency_cipher, memoize: memoize) { initialize ? new : self }
+        @_pluggable.register(
+          initialization_required: initialize,
+          memoization_required: memoize,
+          namespace: scope,
+          code: as
+        )
       end
 
       # @param code [Symbol, String]
-      # @param initialization_block [Proc, nil]
+      # @param initialization_block [Block]
       # @param scope [TrueClass, Symbol, String, nil]
-      # @param as [Symbol, String]
-      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      def resolve(code, initialization_block = nil, scope: true, as: nil)
-        dependency_cipher = Utilities.dependency_cipher(name, scope: scope, code: code)
-        dependency_alias = as || code
-
-        # The process of preloading classes is a bit messy. Therefore, why we wrap the dependency in a Proc.
-        # This allows us not to worry about the absence of the referenced class in the registry during assembly.
-        # Using an initialization block can be convenient in some cases, for example, to resolve some
-        # of the global settings without accessing the whole thing.
-        @_dependencies[dependency_alias] =
-          if initialization_block
-            -> { initialization_block.call(@_registry.resolve(dependency_cipher)) }
-          else
-            -> { @_registry.resolve(dependency_cipher) }
-          end
-
-        # The final step is to declare instance variables and methods to access them.
-        instance_eval do
-          define_method(dependency_alias) do
-            if instance_variable_get("@#{dependency_alias}").is_a?(Proc)
-              instance_variable_get("@#{dependency_alias}").call
-            else
-              instance_variable_get("@#{dependency_alias}")
-            end
-          end
-
-          private dependency_alias
-        end
-
-        singleton_class.class_eval do
-          define_method(dependency_alias) { @_dependencies[dependency_alias].call }
-          private dependency_alias
-        end
+      # @param private [TrueClass, FalseClass]
+      # @param as [Symbol, String, nil]
+      def resolve(code, initialization_block = nil, scope: true, private: true, as: nil)
+        @_pluggable.resolve(code, initialization_block, namespace: scope, private: private, as: as)
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
     end
   end
 end

data/lib/aux/pluggable/connector.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Aux
+  module Pluggable
+    # Describes the bridge between a pluggable class and the registry
+    class Connector
+      # @!attribute [r] dependencies
+      #   @return [Array<Dependency>]
+      attr_reader :dependencies
+
+      # @param subject [Class]
+      # @param registry [Dry::Container]
+      def initialize(subject, registry)
+        @subject = subject
+        @registry = registry
+        @dependencies = []
+
+        configure
+      end
+
+      # @param initialization_required [Boolean] whether the subject requires initialization before use
+      # @param memoization_required [Boolean] whether the subject should be memoized
+      # @param namespace [Symbol] the namespace to register the subject
+      # @param code [Symbol] an alternate name
+      def register(initialization_required: nil, memoization_required: nil, namespace: nil, code: nil)
+        configure(
+          initialization_required: initialization_required,
+          memoization_required: memoization_required,
+          namespace: namespace,
+          code: code
+        )
+
+        # Register the subject in the registry using the provided options
+        @registry.register(@cipher, memoize: @memoization_required) do
+          @initialization_required ? @subject.new : @subject
+        end
+      end
+
+      # @param code [Symbol, String] the name of the dependency
+      # @param initialization_block [Proc] an optional block used to initialize the dependency
+      # @param namespace [TrueClass, Symbol, String, nil] whether to resolve the dependency in the same namespace
+      # @param private [TrueClass, FalseClass] whether to make the dependency private
+      # @param as [Symbol] an internal alias name for the dependency
+      # rubocop:disable Layout/LineLength, Metrics/AbcSize, Metrics/MethodLength
+      def resolve(code, initialization_block = nil, namespace: true, private: true, as: nil)
+        cipher = Utilities.dependency_cipher(@subject.name, scope: namespace, code: code)
+        load_class(cipher) unless @registry.key?(cipher)
+
+        dependency = Dependency.new(@registry.resolve(cipher), initialization_block, pointer: as || code, private: private)
+        @dependencies.push(dependency)
+
+        if @initialization_required
+          @subject.class_eval do
+            define_method(dependency.pointer) { instance_variable_get("@#{dependency.pointer}") }
+            private(dependency.pointer) if dependency.private
+          end
+        else
+          @subject.instance_variable_set("@#{dependency.pointer}", dependency.target)
+          @subject.singleton_class.class_eval do
+            define_method(dependency.pointer) { instance_variable_get("@#{dependency.pointer}") }
+            private(dependency.pointer) if dependency.private
+          end
+        end
+      end
+      # rubocop:enable Layout/LineLength, Metrics/AbcSize, Metrics/MethodLength
+
+      private
+
+      # @param initialization_required [TrueClass, FalseClass, nil]
+      # @param memoization_required [TrueClass, FalseClass, nil]
+      # @param namespace [Symbol, String, nil]
+      # @param code [Symbol, String, nil]
+      def configure(initialization_required: nil, memoization_required: nil, namespace: nil, code: nil)
+        @cipher = Utilities.dependency_cipher(@subject.name, scope: namespace, code: code)
+        @initialization_required = initialization_required
+        @memoization_required = memoization_required
+        @namespace = namespace
+        @code = code
+      end
+
+      # Loads a class specified by the given cipher string. If any of the classes in the cipher string
+      # have not yet been loaded, this method will automatically load them as needed
+      #
+      # @param cipher [String] the string that represents the fully-qualified name of the class
+      # @return [Class] the loaded class
+      def load_class(cipher)
+        cipher.split('.').reduce(Object) do |namespace, class_name|
+          namespace.const_get(class_name.split('_').map(&:capitalize).join)
+        end
+      end
+    end
+  end
+end

data/lib/aux/pluggable/dependency.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Aux
+  module Pluggable
+    # Describes the dependency and its preferences
+    class Dependency
+      # @!attribute [r] target
+      #   @return [Object]
+      # @!attribute [r] pointer
+      #   @return [Symbol, String]
+      # @!attribute [r] private
+      #   @return [Boolean]
+      attr_reader :pointer, :target, :private
+
+      # @param target [Object]
+      # @param initialization_block [Proc, nil]
+      # @param pointer [Symbol, String]
+      # @param private [Boolean]
+      def initialize(target, initialization_block = nil, pointer:, private:)
+        @target = initialization_block ? initialization_block.call(target) : target
+        @pointer = pointer
+        @private = private
+      end
+    end
+  end
+end

data/lib/aux/pluggable/utilities.rb

@@ -8,23 +8,23 @@ module Aux
       # By default, we assume that the developers want to resolve a dependency from the same namespace as the
       # referencing class. Another approach is to allow developers to set the correct scope themselves.
       #
-      # @param class_name [Class]
+      # @param subject [ClassName]
       # @param scope [TrueClass, Symbol, String, nil]
       # @param code [TrueClass, Symbol, String, nil]
       # @return [String]
-      def self.dependency_cipher(class_name, scope: nil, code: nil)
-        native_cipher = dependency_native_cipher(class_name)
+      def self.dependency_cipher(subject, scope: nil, code: nil)
+        native_cipher = dependency_native_cipher(subject)
         native_cipher_partitions = native_cipher.rpartition('.')
-        scope = scope.is_a?(TrueClass) ? native_cipher_partitions.first : scope
+        scope = scope == true ? native_cipher_partitions.first : scope
         code = code.nil? ? native_cipher_partitions.last : code
 
         [scope, code].reject { |part| part.nil? || part.empty? }.join('.')
       end
 
-      # @param class_name [Class]
+      # @param subject [ClassName]
       # @return [String]
-      def self.dependency_native_cipher(class_name)
-        class_name.dup.gsub(/::/, '.').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
+      def self.dependency_native_cipher(subject)
+        subject.dup.gsub(/::/, '.').gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z\d])([A-Z])/, '\1_\2').downcase
       end
     end
   end

data/lib/aux/pluggable.rb

@@ -1,18 +1,21 @@
 # frozen_string_literal: true
 
 require 'aux/pluggable/class_methods'
+require 'aux/pluggable/connector'
+require 'aux/pluggable/dependency'
 require 'aux/pluggable/utilities'
 
 module Aux
   # Describes interface that makes any class able to register itself as well as resolve dependencies
+  # rubocop:disable Style/ClassVars
   module Pluggable
-    # @param base [Class]
+    # Extends the including class with ClassMethods and initializes a new Connector instance
+    # @param base [Class] the class that includes this module
     def self.included(base)
       base.extend(ClassMethods)
 
       base.class_eval do
-        @_registry = @@registry
-        @_dependencies = {}
+        @_pluggable = Connector.new(self, @@registry)
       end
     end
 
@@ -26,4 +29,5 @@ module Aux
       @@registry
     end
   end
+  # rubocop:enable Style/ClassVars
 end

data/lib/aux/validations.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require 'active_support'
+require 'active_model/validations/validates'
 require 'aux/validations/errors'
 
 module Aux
-  # Describes enhancement of {ActiveModel::Validations}
+  # Describes enhancement of {::ActiveModel::Validations}
   module Validations
     extend ActiveSupport::Concern
     include ActiveModel::Validations

data/lib/aux/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Aux
-  VERSION = '0.0.9'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aux
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.1.0
 platform: ruby
 authors:
 - Evgeny Boyko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-19 00:00:00.000000000 Z
+date: 2023-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
@@ -32,18 +32,38 @@ dependencies:
         version: '8'
 - !ruby/object:Gem::Dependency
   name: dry-container
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: '2.5'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: '2.5'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
@@ -70,6 +90,8 @@ files:
 - lib/aux.rb
 - lib/aux/pluggable.rb
 - lib/aux/pluggable/class_methods.rb
+- lib/aux/pluggable/connector.rb
+- lib/aux/pluggable/dependency.rb
 - lib/aux/pluggable/utilities.rb
 - lib/aux/validations.rb
 - lib/aux/validations/error.rb