diana 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d751ec38e00ed56a859741213b470b086262769968e5fbb7abe5ab674cc9a2a
-  data.tar.gz: c46124c639d0af4dc45e8555aa213125440b5957ba54f6fbb787bbb801d02825
+  metadata.gz: 5a42ecda41893911ab6703f513107d3789a191d1a378adf3b4c598816a0cd6ab
+  data.tar.gz: 40fe0dc12e4b06ffb4250e16d9bb2036936fb1fbf219e5dd0a2c55ea4e808919
 SHA512:
-  metadata.gz: 0e5f0c3fb1a0f58a7b159ab6ef40cd3f78d996e2d1a81c83632522caedc67e001e3cf5542a7b81dc8cdb4aec27ff7968c62c7007a63edd6b3ab0570f51c83e9c
-  data.tar.gz: ddf038a682978738d514fe3d5a02bd54f9784e46de8aba83f841eff6a21e5a4abf6713dda9708280f04d46e68c262ff0be4e2d5dbbac9d4f8abe97251f187e9e
+  metadata.gz: db8f596619a96ee92d7c10e893288213cb8697f8e4b4e6523f54565c4e1a8690f713a8afb323de0d46ac1d193891481c0e15772791a58aa28350615fc4798ff0
+  data.tar.gz: 6cb63290c78aa3f332fdb63f996b64ce9b81e6b27e284a8ea7513d6d0eb2616006f376b915ffb473fcc810900b994633a29665d30eb82ebbfe442ac3e379b64b

data/README.md

@@ -66,13 +66,30 @@ By default, dependency methods are **private**. You can change this behavior by
 configuring the Diana module:
 
 ```ruby
-Diana.methods_visibility = :public
+Diana.methods_visibility = :public # private, public, protected
 ```
 
-Using public methods can be more convenient in tests, allowing you to access the
-real dependency and stub its methods, rather than overwriting the dependency
+Using **public** methods can be more convenient in tests, allowing you to access
+the real dependency and stub its methods, rather than overwriting the dependency
 entirely. This approach helps ensure you are testing the correct dependency.
 
+### Inheritance
+
+Classes with included dependencies can be nested. Dependencies from parent and
+child classes are merged.
+
+### Adding dependencies multiple times
+
+`Diana.dependencies` method can be used multiple times. In this case
+dependencies are merged.
+
+```ruby
+class SomeClass
+  include Diana.dependencies(foo: proc { Foo.new })
+  include Diana.dependencies(bar: proc { Bar.new })
+end
+```
+
 ## How it works
 
 - **Dependency Storage**: The `@_diana_dependencies` class variable holds the
@@ -102,17 +119,26 @@ class SomeClass
     bar: proc { Bar.new }
   }
 
+  # handles dependency injection
   def initialize(foo: nil, bar: nil)
     @foo = foo if foo
     @bar = bar if bar
   end
 
+  # handles inheritance
+  def self.inherited(subclass)
+    subclass.include Diana.dependencies(@_diana_dependencies)
+    super
+  end
+
   private
 
+  # handles lazy `foo` resolution
   def foo
     @foo ||= Diana.resolve(self.class.instance_variable_get(:@_diana_dependencies)[:foo])
   end
 
+  # handles lazy `bar` resolution
   def bar
     @bar ||= Diana.resolve(self.class.instance_variable_get(:@_diana_dependencies)[:bar])
   end
@@ -154,12 +180,8 @@ SomeClass.include Diana.dependencies(foo: 'utils.foo') # => DI_CONTAINER['utils.
   method, it will take precedence. In such cases, ensure you include a
   `super(**deps)` call to override dependencies if needed.
 
-- We do not perform any argument modifications and we do not call `super`
-  in dependencies `#initialize` method. This approach is chosen to ensure
-  optimal performance.
-
-- Dependencies defined in a parent class are not accessible in nested classes.
-  You should define dependencies within each class where they are required.
+- We avoid calling `super` in the added `#initialize` method to prevent the need
+  for arguments modifications, which could negatively impact performance.
 
 These limitations ensure that the gem remains predictable and performant,
 avoiding any hidden complexities or unexpected behaviors.

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/diana/config.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
 module Diana
+  #
+  # Defines Diana module configuration methods
+  #
   module Config
     # The default resolver for dependencies.
     DEFAULT_RESOLVER = proc { |dependency| dependency.is_a?(Proc) ? dependency.call : dependency }
@@ -58,13 +61,13 @@ module Diana
     # @example Setting the default visibility of dependency methods to public.
     #   Diana.methods_visibility = :public
     #
-    # @param visibility [Symbol] The new visibility for dependency methods (:private or :public).
+    # @param visibility [Symbol] The new visibility for dependency methods (:private, :public, :protected).
     # @return [Symbol] The new default visibility for dependency methods.
-    # @raise [ArgumentError] If the visibility is not :private or :public.
+    # @raise [ArgumentError] If the visibility is not :private, :public, or :protected.
     #
     def methods_visibility=(visibility)
-      if (visibility != :private) && (visibility != :public)
-        raise ArgumentError, "methods_visibility value must be :private or :public"
+      if (visibility != :private) && (visibility != :public) && (visibility != :protected)
+        raise ArgumentError, "methods_visibility value must be :private, :public, or :protected"
       end
 
       @methods_visibility = visibility

data/lib/diana.rb

@@ -43,11 +43,45 @@ module Diana
     #
     def dependencies(deps)
       Module.new do
+        # Adds readable name to this anonymous module when showing `MyClass.ancestors`
         def self.inspect
           "<Diana.dependencies:#{object_id.to_s(16)}>"
         end
 
+        class_mod = Module.new do
+          # Adds readable name to this anonymous module when showing `MyClass.singleton_class.ancestors`
+          def self.inspect
+            "<Diana.inheritance:#{object_id.to_s(16)}>"
+          end
+
+          private
+
+          def inherited(subclass)
+            # When `inherited` is called for the first time, we add the parent's
+            # `@_diana_dependencies`. To avoid adding dependencies from
+            # ancestors in the `super` call, we check if `@_diana_dependencies`
+            # is already defined.
+            unless subclass.instance_variable_defined?(:@_diana_dependencies)
+              subclass.include Diana.dependencies(@_diana_dependencies)
+            end
+
+            super
+          end
+        end
+
         define_singleton_method(:included) do |base|
+          # Adds .inherited method
+          base.extend(class_mod)
+
+          #
+          # Merging dependencies allows to add dependencies multiple times
+          #
+          # Example:
+          #   class MyClass
+          #     include Diana.dependencies(foo: 'foo')
+          #     include Diana.dependencies(bar: 'bar')
+          #   end
+          #
           merged_deps =
             if base.instance_variable_defined?(:@_diana_dependencies)
               base.instance_variable_get(:@_diana_dependencies).merge!(deps)
@@ -55,6 +89,10 @@ module Diana
               base.instance_variable_set(:@_diana_dependencies, deps.dup)
             end
 
+          # Add initialize method
+          # Instance variables are set only for not-null dependencies.
+          # Using class_eval is slower to define the method, yet it provides the
+          # benefit of executing faster than if it were defined using define_method.
           class_eval(<<~INITIALIZE, __FILE__, __LINE__ + 1)
             def initialize(#{merged_deps.each_key.map { |dependency| "#{dependency}: nil" }.join(", ")})
             #{merged_deps.each_key.map { |dependency| "  @#{dependency} = #{dependency} if #{dependency}" }.join("\n")}
@@ -62,13 +100,16 @@ module Diana
           INITIALIZE
         end
 
+        # Add dependencies attribute readers and set their visibility.
+        # Using class_eval is slower to define the method, yet it provides the
+        # benefit of executing faster than if it were defined using define_method.
         deps.each_key do |dependency|
           class_eval(<<~ATTR_READER, __FILE__, __LINE__ + 1)
             def #{dependency}
               @#{dependency} ||= Diana.resolve(self.class.instance_variable_get(:@_diana_dependencies)[:#{dependency}])
             end
 
-            private :#{dependency} if Diana.methods_visibility == :private
+            #{Diana.methods_visibility} :#{dependency}
           ATTR_READER
         end
       end

metadata

@@ -1,16 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: diana
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Andrey Glushkov
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-17 00:00:00.000000000 Z
+date: 2024-12-18 00:00:00.000000000 Z
 dependencies: []
-description: Lazy Dependency Injection
+description: |
+  Lazy Dependency Injection.
+  Dependencies are allocated only when needed, optimizing performance.
 email:
 - aglushkov@shakuro.com
 executables: []
@@ -26,7 +28,7 @@ homepage: https://github.com/aglushkov/diana
 licenses:
 - MIT
 metadata:
-  source_code_uri: https://github.com/aglushkov/diana
+  homepage_uri: https://github.com/aglushkov/diana
   changelog_uri: https://github.com/aglushkov/diana/blob/master/CHANGELOG.md
 post_install_message:
 rdoc_options: []