infusible 3.0.0 → 3.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ead948e6538cdc8e066bc32341bde9763b3142993cda89a2f3e757bd43cc23f
-  data.tar.gz: c75f2bfe1ea6c13340844d51373a9e82241aee398a2dd29184081520c6381c7b
+  metadata.gz: 6dc14ad940c37db70d202e1c536e89308476388dafb228c79c10632688ae1f80
+  data.tar.gz: 62a63f85a1bad5e32dcf76945705d87cc2ea705c337f9f047473987992d4bfff
 SHA512:
-  metadata.gz: f6609b17d274e75e300c6867310639bb074455af38c0212e988bdf46e7c30e650a0a8000732d067462d2d73162e020a32c84e65e177ea1d2404ceb5e909e84a8
-  data.tar.gz: 46fee24a8fb9a5817139effbb467f66cd13fb03b812ae499423c94695227d6cea24f0cae905c72e99e19744614e4a050018cae5def3e7ba225e8cb57ad175401
+  metadata.gz: fc043d373809d1f649d32d8ed5f0e4f993511c575125f9e02843e7a81f83b5e13bcf15e7ff070866a88a9ffa2b935d1eeb5e7ec961a2f3d9b73b660c6ffce5fe
+  data.tar.gz: 47006245798afea15ba7e440b2c71f8925cbbd649cc0fdb0785612aa7b6716d98bc11cee3bfd720be3c310307ad3a50c7b1d37bf7f3632ffa2cfe4a058176943

data/README.adoc

@@ -10,7 +10,7 @@
 
 Automatically injects dependencies within your object via the _Dependency Inversion Principle_ -- the _D_ in _SOLID_ design -- and is a powerful way to compose complex architectures from small objects which leverage the _Single Responsibility Principle_ -- the _S_ in _SOLID_ design.
 
-This means -- when coupled with {dependency_injection_containers_link} as provided by the {dry-container_link} gem -- Infusible completes the second half of the _Dependency Inversion Principle_. Here's a quick example of Infusible in action:
+When coupled with {dependency_injection_containers_link}, as provided by the {dry-container_link} gem, Infusible completes the second half of the _Dependency Inversion Principle_. Here's a quick example of Infusible in action:
 
 [source,ruby]
 ----
@@ -73,7 +73,7 @@ require "infusible"
 
 == Usage
 
-There is basic and advanced usage. We'll start with basic and work our to advanced usage.
+There is basic and advanced usage. We'll start with the basics and work our to more advanced usage.
 
 === Basic
 
@@ -81,7 +81,7 @@ This gem requires three steps for proper use:
 
 . A container.
 . An import constant.
-. A class and/or multiple classes for dependencies to be injected into.
+. An object and/or multiple objects for dependencies to be injected into.
 
 Let's walk through each staring by defining a container of dependencies.
 
@@ -238,7 +238,7 @@ class Pinger
 end
 ----
 
-The above will ensure the logger gets passed upwards to the superclass while remaining accessible by subclass.
+The above will ensure the logger gets passed upwards to the superclass while remaining accessible by the subclass.
 
 ==== Inheritance
 
@@ -289,7 +289,7 @@ end
 
 With the above, the child class will have access to both the `logger` and `http` dependencies.
 
-⚠️ Be careful when using parent dependencies within your child classes since they are _private by default_. Even though you can reach them, they might change, which can break your downstream dependencies and probably should be avoided or at least defined as `protected` by your parent objects in order to avoid breaking your parent/child relationship.
+⚠️ Be careful when using parent dependencies within your child classes since they are _private by default_. Even though you can reach them, they might change, which can break your downstream dependencies and probably should be avoided or at least defined as `protected` by your parent objects in order to avoid breaking the parent/child relationship.
 
 ==== Scopes
 
@@ -299,7 +299,7 @@ By default -- and in all of the examples shown so far -- your dependencies are p
 * `include Import.protected(logger)`: Injects a _protected_ logger dependency. Useful with inheritance and a subclass needs access to the dependency.
 * `include Import.public(:logger)`: Injects a _public_ logger dependency.
 
-There is no `+#private+` method since `#[]` does this for you and is the recommended practice. Use of `#public` and `+#protected+` should be uses sparingly or not at all if you can avoid it. Here's an example where public, protected, and private dependencies are injected:
+There is no `+#private+` method since `#[]` does this for you and is _recommended practice_. Use of `+#public+` and `+#protected+` should be used sparingly or not at all if you can avoid it. Here's an example where public, protected, and private dependencies are injected:
 
 [source,ruby]
 ----
@@ -326,9 +326,43 @@ demo.two    # NoMethodError: protected method.
 demo.three  # NoMethodError: private method.
 ----
 
+==== Infused Keys
+
+You have access to the keys of all infused dependencies via the _private_ `infused_keys` method which can be powerful in metaprogramming situations. For example, consider the following, which calls all injected dependencies since they have the same Object API (i.e. `#call`):
+
+Example:
+
+[source,ruby]
+----
+module Container
+  extend Dry::Container::Mixin
+
+  register(:one, proc { puts "One" }, call: false)
+  register(:two, proc { puts "Two" }, call: false)
+end
+
+Import = Infusible.with Container
+
+class Demo
+  include Import[:one, :two]
+
+  def call = infused_keys.each { |key| __send__(key).call }
+end
+
+Demo.new.call
+# One
+# Two
+----
+
+As you can see, with the _private_ `#infused_keys` attribute reader, we are able to iterate through each infused key and send the `#call` message to each injected dependency.
+
+Since `#infused_keys` is a private attribute reader, this means the infused keys are private to each instance. This includes all ancestors when using inheritance as each super class in the hierarchy will have it's own unique array of infused keys depending on what was injected for that object.
+
+All infused keys are frozen by default.
+
 === Tests
 
-As you architect your implementation, you'll want to test your injected dependencies. You'll also want to stub, mock, or spy on them as well. Testing support is built-in for you by only needing to require the stub refinement as provided by this gem. For demonstration purposes, I'm going to assume you are using RSpec but you can adapt for whatever testing framework you are using.
+As you architect your implementation, you'll want to test your injected dependencies. You might want to stub, mock, or spy on them as well. Test support is built-in for you by only requiring the stub refinement as provided by this gem. For demonstration purposes, I'll assume you are using RSpec but you can adapt for whatever testing framework you are using.
 
 Let's say you have the following implementation that combines both {dry-container_link} (or a primitive `Hash` would work too) and this gem:
 
@@ -381,7 +415,7 @@ RSpec.describe Action do
 end
 ----
 
-Notice that there is very little setup required to test the injected dependencies. You only need to use the refinement and define what you want stubbed in your `before` and `after` blocks. That's it!
+Notice there is little setup required to test the injected dependencies. You only need to use the refinement and define what you want stubbed in your `before` and `after` blocks. That's it!
 
 While the above works great for a single spec, over time you'll want to reduce duplicated setup by using a shared context. Here's a rewrite of the above spec which significantly reduces duplication when needing to test multiple objects using the same dependencies:
 
@@ -453,7 +487,7 @@ bin/console
 
 === Architecture
 
-This gem automates a lot of the boilerplate code you'd normally have to do manually by defining your constructor, initializer, and instance variables for you. Normally, when injecting dependencies, you'd do something like this (using the `Pinger` example provided earlier):
+This gem automates a lot of the boilerplate code you'd manually do by defining your constructor, initializer, and instance variables for you. Normally, when injecting dependencies, you'd do something like this (using the `Pinger` example provided earlier):
 
 [source,ruby]
 ----
@@ -493,10 +527,10 @@ Your constructor, initializer, and instance variables are all there. Only you do
 When using this gem, along with a container like {dry-container_link}, make sure to adhere to the following guidelines:
 
 * Use containers to group related dependencies that make logical sense for the namespace you are working in and avoid using containers as a junk drawer for throwing random objects in.
-* Use containers that don't have a lot of registered dependencies. If you register too many dependencies, then that means your objects are too complex and need to be simplified further.
+* Use containers that don't have a lot of registered dependencies. If you register too many dependencies, that means your objects are too complex and need to be simplified further.
 * Use the `Import` constant to define _what_ is possible to import much like you'd use a `Container` to define your dependencies. Defining what is importable improves performance and should be defined in separate files for improved fuzzy file finding.
 * Use `**` to forward keyword arguments when defining an initializer which needs to pass injected dependencies upwards.
-* Prefer `Import#[]` over the use of `Import#public` and/or `Import#protected` as much as a possible since injected dependencies should be private, by default, in order to not break encapsulation. That said, there are times where making them public and/or protected can save you from writing more boilerplate code.
+* Prefer `Import#[]` over the use of `Import#public` and/or `Import#protected` as much as a possible since injected dependencies should be private, by default, in order to not break encapsulation. That said, there are times where making them public and/or protected can save you from writing boilerplate code.
 
 == Tests
 

data/infusible.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "infusible"
-  spec.version = "3.0.0"
+  spec.version = "3.2.0"
   spec.authors = ["Brooke Kuhlmann"]
   spec.email = ["brooke@alchemists.io"]
   spec.homepage = "https://alchemists.io/projects/infusible"

data/lib/infusible/constructor.rb

@@ -7,6 +7,10 @@ module Infusible
   # :reek:TooManyInstanceVariables
   class Constructor < Module
     def self.define_instance_variables target, names, keywords
+      unless target.instance_variable_defined? :@infused_keys
+        target.instance_variable_set :@infused_keys, names
+      end
+
       names.each do |name|
         next unless keywords.key?(name) || !target.instance_variable_defined?(:"@#{name}")
 
@@ -26,20 +30,25 @@ module Infusible
       @instance_module = Class.new(Module).new
     end
 
-    def included klass
+    def included descendant
+      unless descendant.is_a? Class
+        fail TypeError,
+             "Can only infuse a class, invalid object: #{descendant} (#{descendant.class})."
+      end
+
       super
-      define klass
-      klass.extend class_module
-      klass.include instance_module
+      define descendant
+      descendant.extend class_module
+      descendant.include instance_module
     end
 
     private
 
     attr_reader :container, :dependencies, :scope, :class_module, :instance_module
 
-    def define klass
+    def define descendant
       define_new
-      define_initialize klass
+      define_initialize descendant
       define_readers
     end
 
@@ -52,8 +61,8 @@ module Infusible
       end
     end
 
-    def define_initialize klass
-      super_parameters = Marameters.of(klass, :initialize).map do |instance|
+    def define_initialize descendant
+      super_parameters = Marameters.of(descendant, :initialize).map do |instance|
         break instance unless instance.only_bare_splats?
       end
 
@@ -94,6 +103,7 @@ module Infusible
       computed_scope = METHOD_SCOPES.include?(scope) ? scope : :private
 
       instance_module.module_eval <<-READERS, __FILE__, __LINE__ + 1
+        attr_reader :infused_keys
         #{computed_scope} attr_reader #{methods.join ", "}
       READERS
     end

data/lib/infusible/dependency_map.rb

@@ -11,13 +11,12 @@ module Infusible
       @patterns = patterns
       @collection = {}
 
-      configuration = configuration.dup
       aliases = configuration.last.is_a?(Hash) ? configuration.pop : {}
 
       configuration.each { |identifier| add to_name(identifier), identifier }
       aliases.each { |name, identifier| add name, identifier }
 
-      @names = collection.keys
+      @names = collection.keys.freeze
     end
 
     def to_h = collection

data.tar.gz.sig

@@ -1 +1 @@
-R��9�i*_u߼�ū`��4>n|z�~�B7YU']zԶ�����\�W��n�j!MO���$k�<c���c]��>PYv�wL8��E�n�:P��G��~�<�\@f��J��x�ߋٻ�6�9�5�N�K
+r��K��ߨ�ɨ���w
G�`#,�`�ڮ{��[����I�g������

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: infusible
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.2.0
 platform: ruby
 authors:
 - Brooke Kuhlmann
@@ -35,7 +35,7 @@ cert_chain:
   3n5C8/6Zh9DYTkpcwPSuIfAga6wf4nXc9m6JAw8AuMLaiWN/r/2s4zJsUHYERJEu
   gZGm4JqtuSg8pYjPeIJxS960owq+SfuC+jxqmRA54BisFCv/0VOJi7tiJVY=
   -----END CERTIFICATE-----
-date: 2024-01-01 00:00:00.000000000 Z
+date: 2024-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: marameters
@@ -110,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: An automated dependency manager and injector.