infusible 3.4.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 85febc0a6baf5496a158e328b14c18d15857f5572ea39887eab2022750e9244a
-  data.tar.gz: db1e0053fd1a19ea62b2de784ae98c8b3c7a1afceb916c2075bb9dd1f47df04e
+  metadata.gz: 4f99dc573cc9c1527b47b04688ff4535369eed4669d52efa98b523fd95ff0c19
+  data.tar.gz: 9b1abb691f026e8277c6e5a9a9a1e095b8682879d62e5f0eff6dcff60e21bf33
 SHA512:
-  metadata.gz: 1772ad6440f0db0fbc6998bf4452ac4dfa3be02560309177a1f79dccf2be4649534eb64aa28860101b356b11b22fe963370dccccc7780e8634d5ef8182023d54
-  data.tar.gz: 6a9c9d3e65f1b3c37211bf1aa2858081f2d949334f9ca95bc43d0249d4e5b31d7ddd8964c0e12639636932e3fc21264494c612408d45ff1e938d8259599d33b5
+  metadata.gz: e860e15f851c44d236630445e5c14ac878d4d9d603757979d6e1da5f5bfb2e6ef5f6f996db85d62cfefb9fd05fec632244ab5d6ede21f3cd541a5b5c3abd912b
+  data.tar.gz: 6b8718be08634a780d7b8197f2065648bed8cb01172007a3eacfba5d91261885f97126afd824ee5a72e5603ade8a985bcdcdc52d219e0f085d11616af4dd10c7

data/README.adoc

@@ -3,18 +3,18 @@
 :figure-caption!:
 
 :dependency_injection_containers_link: link:https://alchemists.io/articles/dependency_injection_containers[Dependency Injection Containers]
-:dry-container_link: link:https://dry-rb.org/gems/dry-container[Dry Container]
+:containable_link: link:https://alchemists.io/projects/containable[Containable]
 :http_link: link:https://github.com/httprb/http[HTTP]
 
 = Infusible
 
 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.
 
-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 {containable_link} gem, Infusible completes the second half of the _Dependency Inversion Principle_. Here's a quick example of Infusible in action:
 
 [source,ruby]
 ----
-Import = Infusible.with({a: 1, b: 2, c: 3})
+Import = Infusible[a: 1, b: 2, c: 3]
 
 class Demo
   include Import[:a, :b, :c]
@@ -87,32 +87,33 @@ Let's walk through each staring by defining a container of dependencies.
 
 ==== Containers
 
-A container provides a common object for which you can group related dependencies for injection and reuse. {dry-container_link} is recommended for defining your dependencies but a primitive `Hash` or any object which responds to the `#[]` message works too.
+A container provides a common object for which you can group related dependencies for injection and reuse. {containable_link} is recommended for defining your dependencies but a primitive `Hash` or any object which responds to the `#[]` message works too.
 
-For documentation purposes, the {dry-container_link} gem will be used. The following creates a simple container where you might want to use the {http_link} gem to make HTTP requests and log information using Ruby's native logger.
+For documentation purposes, the {containable_link} gem will be used. The following creates a simple container where you might want to use the {http_link} gem to make HTTP requests and log information using Ruby's native logger.
 
 [source,ruby]
 ----
+require "containable"
 require "http"
 require "logger"
 
 module Container
-  extend Dry::Container::Mixin
+  extend Containable
 
-  register(:http) { HTTP }
+  register :http, HTTP
   register(:logger) { Logger.new STDOUT }
 end
 ----
 
-==== Injectors
+==== Imports
 
-Once your container is defined, you'll want to define the corresponding injector for reuse within your application. Defining an injector only requires two lines of code:
+Once your container is defined, you'll want to define the corresponding import for reuse within your application. Defining an import only requires two lines of code:
 
 [source,ruby]
 ----
 require "infusible"
 
-Import = Infusible.with Container
+Import = Infusible[Container]
 ----
 
 ==== Dependencies
@@ -168,7 +169,7 @@ class Pinger
 end
 ----
 
-The namespace (i.e. `primary.`) _and_ delimiter (i.e. `.`) will be removed so only `http` and `logger` are defined for use (as shown in the `#call` method). Only dots (i.e. `.`) are allowed as the delimiter between namespace and dependency.
+The namespace (i.e. `primary`) _and_ delimiter (i.e. `.`) will be removed so only `http` and `logger` are defined for use (as shown in the `#call` method). Only dots (i.e. `.`) are allowed as the delimiter between namespace and dependency.
 
 ==== Aliases
 
@@ -216,7 +217,7 @@ class Downloader
 end
 ----
 
-This allows you to reuse your importer (i.e. `Import`) in as many situations as makes sense while improving performance.
+This allows you to reuse `Import` in as many situations as makes sense while improving performance.
 
 ==== Custom Initialization
 
@@ -296,7 +297,7 @@ With the above, the child class will have access to both the `logger` and `http`
 By default -- and in all of the examples shown so far -- your dependencies are private by default when injected but you can make them public or protected. Here's a quick guide:
 
 * `include Import[:logger]`: Injects a _private_ logger dependency.
-* `include Import.protected(logger)`: Injects a _protected_ logger dependency. Useful with inheritance and a subclass needs access to the dependency.
+* `include Import.protected(logger)`: Injects a _protected_ logger dependency. Useful with inheritance and a subclass that 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 _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:
@@ -304,14 +305,14 @@ There is no `+#private+` method since `#[]` does this for you and is _recommende
 [source,ruby]
 ----
 module Container
-  extend Dry::Container::Mixin
+  extend Containable
 
-  register(:one) { "One" }
-  register(:two) { "Two" }
-  register(:three) { "Three" }
+  register :one, "One"
+  register :two, "Two"
+  register :three, "Three"
 end
 
-Import = Infusible.with Container
+Import = Infusible[Container]
 
 class Demo
   include Import.public(:one)
@@ -326,27 +327,27 @@ demo.two    # NoMethodError: protected method.
 demo.three  # NoMethodError: private method.
 ----
 
-==== Infused Names
+==== Infused Keys
 
-You have access to the names of all infused dependencies via the _private_ `#infused_names` method which is powerful in metaprogramming situations. For example, consider the following which calls all injected dependencies since they have the same Object API (i.e. `#call`):
+You have access to the keys of all dependencies via the _private_ `#infused_keys` method which is 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
+  extend Containable
 
-  register(:one, proc { puts "One" }, call: false)
-  register(:two, proc { puts "Two" }, call: false)
+  register :one, "One"
+  register :two, "Two"
 end
 
-Import = Infusible.with Container
+Import = Infusible[Container]
 
 class Demo
   include Import[:one, :two]
 
-  def call = infused_names.each { |key| __send__(key).call }
+  def call = infused_keys.each { |key| puts __send__(key) }
 end
 
 Demo.new.call
@@ -354,29 +355,27 @@ Demo.new.call
 # Two
 ----
 
-As you can see, with the _private_ `#infused_names` attribute reader, we are able to iterate through each infused name and send the `#call` message to each injected dependency.
+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_names` is a private attribute reader, this means the infused names are private to each instance. This includes all ancestors when using inheritance as each parent class in the hierarchy will have it's own unique array of infused names depending on what was injected for that object.
+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 parent class in the hierarchy will have it's own unique array of infused keys depending on what was injected for that object.
 
-All infused names are frozen by default.
+All infused keys are frozen by default.
 
 === Tests
 
-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:
+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 primarily provided via the {containable_link} gem. Example:
 
 [source,ruby]
 ----
 # Our container with a single dependency.
 module Container
-  extend Dry::Container::Mixin
+  extend Containable
 
-  register(:kernel) { Kernel }
+  register :kernel, Kernel
 end
 
 # Our import which defines our container for potential injection.
-Import = Infusible.with Container
+Import = Infusible[Container]
 
 # Our action class which injects our kernel dependency from our container.
 class Action
@@ -390,21 +389,14 @@ With our implementation defined, we can test as follows:
 
 [source,ruby]
 ----
-# Required: You must require Dry Container and Infusible stubbing for testing purposes.
-require "dry/container/stub"
-require "infusible/stub"
-
 RSpec.describe Action do
-  # Required: You must refine Infusible to leverage stubbing of your dependencies.
-  using Infusible::Stub
-
   subject(:action) { Action.new }
 
   let(:kernel) { class_spy Kernel }
 
-  # Required: You must define what dependencies you want to stub and unstub before and after a test.
-  before { Import.stub kernel: }
-  after { Import.unstub :kernel }
+  before { Container.stub! kernel: }
+
+  after { Container.restore }
 
   describe "#call" do
     it "prints message" do
@@ -415,23 +407,19 @@ RSpec.describe Action do
 end
 ----
 
-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!
+Notice there is little setup required to test the injected dependencies. You only need to stub and restore via 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:
 
 [source,ruby]
 ----
 # spec/support/shared_contexts/application_container.rb
-require "dry/container/stub"
-require "infusible/stub"
-
 RSpec.shared_context "with application dependencies" do
-  using Infusible::Stub
-
   let(:kernel) { class_spy Kernel }
 
-  before { Import.stub kernel: }
-  after { Import.unstub :kernel }
+  before { Container.stub! kernel: }
+
+  after { Container.restore }
 end
 ----
 
@@ -452,20 +440,7 @@ RSpec.describe Action do
 end
 ----
 
-A shared context allows you to reuse it across multiple specs by including it as needed.
-
-In both spec examples -- so far -- you'll notice only RSpec `before` and `after` blocks are used. You can use an `around` block too. Example:
-
-[source,ruby]
-----
-around do |example|
-  Import.stub_with kernel: FakeKernel do
-    example.run
-  end
-end
-----
-
-⚠️ I mention `around` block support last because the caveat is that you can't use an `around` block with any RSpec test double since link:https://github.com/rspec/rspec-mocks/issues/1283[RSpec can't guarantee proper cleanup]. This is why the RSpec `before` and `after` blocks were used to guarantee proper setup and teardown. That said, you can use _fakes_ or any object you own which _isn't_ a RSpec test double but provides the Object API you need for testing purposes.
+A shared context allows for reuse across multiple specs by including it as needed.
 
 == Development
 
@@ -524,7 +499,7 @@ Your constructor, initializer, and instance variables are all there. Only you do
 
 === Style Guide
 
-When using this gem, along with a container like {dry-container_link}, make sure to adhere to the following guidelines:
+When using this gem, along with a container like {containable_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, that means your objects are too complex and need to be simplified further.

data/infusible.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "infusible"
-  spec.version = "3.4.0"
+  spec.version = "3.6.0"
   spec.authors = ["Brooke Kuhlmann"]
   spec.email = ["brooke@alchemists.io"]
   spec.homepage = "https://alchemists.io/projects/infusible"
@@ -23,7 +23,7 @@ Gem::Specification.new do |spec|
   spec.cert_chain = [Gem.default_cert_path]
 
   spec.required_ruby_version = "~> 3.3"
-  spec.add_dependency "marameters", "~> 3.0"
+  spec.add_dependency "marameters", "~> 3.3"
 
   spec.extra_rdoc_files = Dir["README*", "LICENSE*"]
   spec.files = Dir["*.gemspec", "lib/**/*"]

data/lib/infusible/constructor.rb

@@ -6,16 +6,16 @@ module Infusible
   # Provides the automatic and complete resolution of all injected dependencies.
   # :reek:TooManyInstanceVariables
   class Constructor < Module
-    def self.define_instance_variables target, names, keywords
+    def self.define_instance_variables target, keys, keywords
       unless target.instance_variable_defined? :@infused_keys
-        target.instance_variable_set :@infused_names, names
-        target.instance_variable_set :@infused_keys, names
+        target.instance_variable_set :@infused_names, keys
+        target.instance_variable_set :@infused_keys, keys
       end
 
-      names.each do |name|
-        next unless keywords.key?(name) || !target.instance_variable_defined?(:"@#{name}")
+      keys.each do |key|
+        next unless keywords.key?(key) || !target.instance_variable_defined?(:"@#{key}")
 
-        target.instance_variable_set :"@#{name}", keywords[name]
+        target.instance_variable_set :"@#{key}", keywords[key]
       end
     end
 
@@ -77,39 +77,39 @@ module Infusible
     end
 
     def define_initialize_with_positionals super_parameters, variablizer
-      instance_module.module_exec dependencies.names, variablizer do |names, definer|
+      instance_module.module_exec dependencies.keys, variablizer do |keys, definer|
         define_method :initialize do |*positionals, **keywords, &block|
-          definer.call self, names, keywords
+          definer.call self, keys, keywords
 
           if super_parameters.only_single_splats?
             super(*positionals, **keywords, &block)
           else
-            super(*positionals, **super_parameters.keyword_slice(keywords, keys: names), &block)
+            super(*positionals, **super_parameters.keyword_slice(keywords, keys:), &block)
           end
         end
       end
     end
 
     def define_initialize_with_keywords super_parameters, variablizer
-      instance_module.module_exec dependencies.names, variablizer do |names, definer|
+      instance_module.module_exec dependencies.keys, variablizer do |keys, definer|
         define_method :initialize do |**keywords, &block|
-          definer.call self, names, keywords
-          super(**super_parameters.keyword_slice(keywords, keys: names), &block)
+          definer.call self, keys, keywords
+          super(**super_parameters.keyword_slice(keywords, keys:), &block)
         end
       end
     end
 
     def define_readers
-      methods = dependencies.names.map { |name| ":#{name}" }
+      methods = dependencies.keys.map { |key| ":#{key}" }
       computed_scope = METHOD_SCOPES.include?(scope) ? scope : :private
 
       instance_module.module_eval <<-READERS, __FILE__, __LINE__ + 1
-        attr_reader :infused_names
+        attr_reader :infused_keys
 
-        def infused_keys
-          warn "Inusible `#infused_keys` is deprecated, use `#infused_names` instead.",
+        def infused_names
+          warn "`Inusible#infused_names` is deprecated, use `#infused_keys` instead.",
                category: :deprecated
-          @infused_keys
+          @infused_names
         end
 
         #{computed_scope} attr_reader #{methods.join ", "}

data/lib/infusible/dependency_map.rb

@@ -3,9 +3,9 @@
 module Infusible
   # Sanitizes and resolves dependencies for use.
   class DependencyMap
-    PATTERNS = {name: /([a-z_][a-zA-Z_0-9]*)$/, valid: /^[\w.]+$/}.freeze
+    PATTERNS = {key: /([a-z_][a-zA-Z_0-9]*)$/, valid: /^[\w.]+$/}.freeze
 
-    attr_reader :names
+    attr_reader :keys
 
     def initialize *configuration, patterns: PATTERNS
       @patterns = patterns
@@ -13,10 +13,10 @@ module Infusible
 
       aliases = configuration.last.is_a?(Hash) ? configuration.pop : {}
 
-      configuration.each { |identifier| add to_name(identifier), identifier }
-      aliases.each { |name, identifier| add name, identifier }
+      configuration.each { |identifier| add to_key(identifier), identifier }
+      aliases.each { |key, identifier| add key, identifier }
 
-      @names = collection.keys.freeze
+      @keys = collection.keys.freeze
     end
 
     def to_h = collection
@@ -25,20 +25,20 @@ module Infusible
 
     attr_reader :patterns, :collection
 
-    def to_name identifier
-      name = identifier[patterns.fetch(:name)]
+    def to_key identifier
+      key = identifier[patterns.fetch(:key)]
 
-      return name if name && name.match?(patterns.fetch(:valid))
+      return key if key && key.match?(patterns.fetch(:valid))
 
       fail(Errors::InvalidDependency.new(identifier:))
     end
 
-    def add name, identifier
-      name = name.to_sym
+    def add key, identifier
+      key = key.to_sym
 
-      return collection[name] = identifier unless collection.key? name
+      return collection[key] = identifier unless collection.key? key
 
-      fail Errors::DuplicateDependency.new name:, identifier:
+      fail Errors::DuplicateDependency.new key:, identifier:
     end
   end
 end

data/lib/infusible/errors/duplicate_dependency.rb

@@ -4,8 +4,8 @@ module Infusible
   module Errors
     # Prevents duplicate dependencies from being injected.
     class DuplicateDependency < StandardError
-      def initialize name:, identifier:
-        super "Remove #{identifier.inspect} since it's a duplicate of #{name.inspect}."
+      def initialize key:, identifier:
+        super "Remove #{identifier.inspect} since it's a duplicate of #{key.inspect}."
       end
     end
   end

data/lib/infusible/stub.rb

@@ -7,14 +7,27 @@ module Infusible
   module Stub
     refine Actuator do
       def stub_with(pairs, &)
+        warn "`#{self.class}##{__method__}` is deprecated, use the Containable gem instead.",
+             category: :deprecated
+
         return unless block_given?
 
         container.is_a?(Hash) ? stub_hash_with(pairs, &) : stub_container_with(pairs, &)
       end
 
-      def stub(pairs) = container.is_a?(Hash) ? stub_hash(pairs) : stub_container(pairs)
+      def stub pairs
+        warn "`#{self.class}##{__method__}` is deprecated, use the Containable gem instead",
+             category: :deprecated
+
+        container.is_a?(Hash) ? stub_hash(pairs) : stub_container(pairs)
+      end
 
-      def unstub(*keys) = container.is_a?(Hash) ? unstub_hash(*keys) : unstub_container(*keys)
+      def unstub(*keys)
+        warn "`#{self.class}##{__method__}` is deprecated, use the Containable gem instead",
+             category: :deprecated
+
+        container.is_a?(Hash) ? unstub_hash(*keys) : unstub_container(*keys)
+      end
 
       private
 

data/lib/infusible.rb

@@ -10,5 +10,10 @@ require "infusible/errors/invalid_dependency"
 module Infusible
   METHOD_SCOPES = %i[public protected private].freeze
 
-  def self.with(container) = Actuator.new container
+  def self.[](container) = Actuator.new container
+
+  def self.with container
+    warn "`Infusible.#{__method__}` is deprecated, use `.[]` instead.", category: :deprecated
+    Actuator.new container
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: infusible
 version: !ruby/object:Gem::Version
-  version: 3.4.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Brooke Kuhlmann
@@ -35,7 +35,7 @@ cert_chain:
   3n5C8/6Zh9DYTkpcwPSuIfAga6wf4nXc9m6JAw8AuMLaiWN/r/2s4zJsUHYERJEu
   gZGm4JqtuSg8pYjPeIJxS960owq+SfuC+jxqmRA54BisFCv/0VOJi7tiJVY=
   -----END CERTIFICATE-----
-date: 2024-03-09 00:00:00.000000000 Z
+date: 2024-04-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: marameters
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.3'
 description:
 email:
 - brooke@alchemists.io
@@ -96,7 +96,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.6
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: An automated dependency manager and injector.