diana 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1a01d25056de39c12dc7b080474f96d2e3645294f77fc199e1ea486d9db4045c
-  data.tar.gz: 89722a0df0f1d63a265fd84e46afc37198ec6311f468ac93b4ef5fec9f0bce0d
+  metadata.gz: 5a42ecda41893911ab6703f513107d3789a191d1a378adf3b4c598816a0cd6ab
+  data.tar.gz: 40fe0dc12e4b06ffb4250e16d9bb2036936fb1fbf219e5dd0a2c55ea4e808919
 SHA512:
-  metadata.gz: 6f45f231f1e32a68559cd6bf8ded95c997e8c58bf346611b3d33a46dc547cc9426af536771104ee798dbce70da2804f1672253146e1a70a6d8a42c430f9a28ba
-  data.tar.gz: 8e6cfd282fb550df593cd46a04a4e6bc582181dc564e76999c9d41cb9008a5f6bb3c1d0d0c1f453835eb2776a4f913d42816699f30b47a6e3c8e5d15c97a21cf
+  metadata.gz: db8f596619a96ee92d7c10e893288213cb8697f8e4b4e6523f54565c4e1a8690f713a8afb323de0d46ac1d193891481c0e15772791a58aa28350615fc4798ff0
+  data.tar.gz: 6cb63290c78aa3f332fdb63f996b64ce9b81e6b27e284a8ea7513d6d0eb2616006f376b915ffb473fcc810900b994633a29665d30eb82ebbfe442ac3e379b64b

data/README.md

@@ -1,3 +1,8 @@
+[![Gem Version](https://badge.fury.io/rb/diana.svg)](https://badge.fury.io/rb/diana)
+[![GitHub Actions](https://github.com/aglushkov/diana/actions/workflows/main.yml/badge.svg?event=push)](https://github.com/aglushkov/diana/actions/workflows/main.yml)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/9e874aec44744552e642/test_coverage)](https://codeclimate.com/github/aglushkov/diana/test_coverage)
+[![Maintainability](https://api.codeclimate.com/v1/badges/9e874aec44744552e642/maintainability)](https://codeclimate.com/github/aglushkov/diana/maintainability)
+
 # Diana - Lazy Dependency Injection
 
 This module offers a DSL designed for the lazy resolution of dependency injections.
@@ -61,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
@@ -97,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
@@ -149,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.0
+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,22 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: diana
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  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: |
-  This module offers a DSL designed for the lazy resolution of dependency injections.
-
-  It facilitates efficient and deferred initialization of dependencies,
-  ensuring that resources are only allocated when necessary.
-
-  This approach optimizes performance of application.
+  Lazy Dependency Injection.
+  Dependencies are allocated only when needed, optimizing performance.
 email:
 - aglushkov@shakuro.com
 executables: []