aux 0.0.8 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f503f7b2c93409d49d479fae673bd7fa87a34e52f810597db2b5ea7cc74325d9
-  data.tar.gz: 6294d1a412b7da15c43f8959e25b7a420efa3a5d9a73cd5fe1ad899745d70a5f
+  metadata.gz: f7ab27a48b02884baff3dedd1a770d02a71be57471b40aaabfd1213068dfd317
+  data.tar.gz: 1e38945b37770dc63d2280c1b000cff18b96d06b6544430480c815ab571213ac
 SHA512:
-  metadata.gz: e2e8123f2550f6da88a40f9cecbbea4b53d0a318e2f987c8b6955ef2523dce30027c53fe0313feab8c64d8cf1165e736dcdbd10e1764ec6eea7d8d7277a48601
-  data.tar.gz: 7374bff3510b50391575acda6f9ddd206cafe4c742619b1699e5d19728df0c63031c3f021d7286d5c4a4e0c5c60b2d126bf66a2db5d9978aeb0006ee0014668f
+  metadata.gz: 05c2d14e99306c482ca584ca330e0808e653bab12082c5726dfd8495370f1109646afa0a7985c948d180715ce4aa074d4c0eb9cb8f58d409dab30305fb2fcdc3
+  data.tar.gz: 116352323a5886ac2e2c8eeafe0a55687bd5e6e37d29e4eb66b4b4c76eb7ad5e7ba5eefbdaec0a7c25cc6afe77318713cef01fcab95aeee957dbc3726b15c986

data/aux.gemspec

@@ -10,9 +10,10 @@ Gem::Specification.new do |specification|
   specification.email = ['eboyko@eboyko.ru']
   specification.homepage = 'https://github.com/eboyko/aux'
 
-  specification.add_dependency 'activemodel', '~> 6.1.6'
+  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)
+        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.8'
+  VERSION = '0.1.0'
 end

metadata

@@ -1,43 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: aux
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.1.0
 platform: ruby
 authors:
 - Evgeny Boyko
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-03-14 00:00:00.000000000 Z
+date: 2023-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemodel
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 6.1.6
+        version: '8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: 6.1.6
+        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
@@ -64,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