inoculate 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e63449f9ee05019e70acf85faafd0f2adf6554704f560de31b66b12c01e54aeb
-  data.tar.gz: e6975710a5802d37bd4b84de1345dbd10a10a5cf8538096cd8ffea8459997af9
+  metadata.gz: 7bd8610b9bbde1304734505a64fdf22c8665961e3b02d93171ac4fc6ccf313aa
+  data.tar.gz: 66ee174fa4bd02dfd671a39a946a8343da1d63bb88f9be05ee94816d033a5e4e
 SHA512:
-  metadata.gz: 95e7e8d09278118af12987096c2919419a66b6ea298d6556a3e7df113403e0fa4edd363a1d19172eef8d4739ffdf10b4e8180b19151cdd19361d3c2ccd861200
-  data.tar.gz: 9dd927feda03995336037f58b86e9c97be8e2bf83f4ac8a101ee67b10e0d40106bdf0f62a138ef046135ef24f759074c289ef61153c8044d02db08b63e4b20be
+  metadata.gz: bbc2655324e68cd2ad977192b81f9cbef0d63b72da91f05521c59eb91f1d58993da68dbcd8d4f6b69be5e5d93708e847f567955f80cb042761e187b64c1bcdbc
+  data.tar.gz: ef316f9b6e6dfa9cd42811f8af5082f402d0c03478a280a2728b61ce9c706a9e0b1cd0249921d18818cfa85b28ccf81969a1330744c3d8d19e95e5fd4f73a81c

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## v0.4.0 \[Unreleased]
+
+* Add singleton dependency registration.
+
+## v0.3.0 \[2022-10-11]
+
+* Add instance dependency registration.
+* Only allow blocks (and Procs) as dependency factories.
+
 ## v0.2.0 \[2022-10-11]
 
 * Build modules at initialization time so that usage is always thread-safe.

data/README.md

@@ -24,6 +24,8 @@ It provides several life-cycles and provides dependency access through private a
 2. [Usage](#usage)
    1. [Dependency Life Cycles](#dependency-life-cycles)
       1. [Transient](#transient)
+      2. [Instance](#instance)
+      3. [Singleton](#singleton)
    2. [Renaming the Declaration API](#renaming-the-declaration-api)
    3. [Hide Your Dependency on Inoculate](#hide-your-dependency-on-inoculate)
 3. [Installation](#installation)
@@ -99,16 +101,115 @@ class Example
    end
 end
 
-puts Example.new
+a = Example.new
+puts a, a, a
 ```
 
 This results in:
 
 ```
 Count is: 0
+Count is: 0
+Count is: 0
 => nil    
 ```
 
+#### Instance
+Instance dependencies are constructed once for each instance of a dependent class.
+
+```ruby
+class Counter
+   attr_reader :count
+
+   def initialize
+      @count = 0
+   end
+   
+   def inc
+      @count += 1
+   end
+end
+
+Inoculate.initialize do |config|
+   config.instance(:counter) { Counter.new }
+end
+
+class Example
+   include Inoculate::Porter
+   inoculate_with :counter
+   
+   def initialize(name)
+      @name = name
+   end
+   
+   def to_s
+      counter.inc
+      "[#{@name}] Count is: #{counter.count}"
+   end
+end
+
+a = Example.new("a")
+b = Example.new("b")
+puts a, a, b
+```
+
+This results in:
+
+```
+[a] Count is: 1
+[a] Count is: 2
+[b] Count is: 1
+=> nil  
+```
+
+#### Singleton
+Singleton dependencies are constructed once.
+
+```ruby
+class Counter
+   attr_reader :count
+
+   def initialize
+      @count = 0
+   end
+   
+   def inc
+      @count += 1
+   end
+end
+
+Inoculate.initialize do |config|
+   config.singleton(:counter) { Counter.new }
+end
+
+class Example
+   include Inoculate::Porter
+   inoculate_with :counter
+   
+   def initialize(name)
+      @name = name
+   end
+   
+   def to_s
+      counter.inc
+      "[#{@name}] Count is: #{counter.count}"
+   end
+end
+
+a = Example.new("a")
+b = Example.new("b")
+puts a, a, b
+```
+
+This results in:
+
+```
+[a] Count is: 1
+[a] Count is: 2                         
+[b] Count is: 3                         
+=> nil   
+```
+
 ### Renaming the Declaration API
 The `inoculate_with` API is named to avoid immediate collisions with other modules
 and code you may have. You can use it as-is, or rename it to something you see fit

data/lib/inoculate/configurer.rb

@@ -13,8 +13,27 @@ module Inoculate
     # @see Manufacturer#transient
     #
     # @since 0.1.0
-    def transient(name, builder = nil, &block)
-      manufacturer.transient(name, builder, &block)
+    def transient(name, &block)
+      manufacturer.transient(name, &block)
+      nil
+    end
+
+    # Register an instance dependency.
+    # @see Manufacturer#instance
+    #
+    # @since 0.3.0
+    def instance(name, &block)
+      manufacturer.instance(name, &block)
+      nil
+    end
+
+    # Register a singleton dependency.
+    # @see Manufacturer#singleton
+    #
+    # @since 0.4.0
+    def singleton(name, &block)
+      manufacturer.singleton(name, &block)
+      nil
     end
 
     private

data/lib/inoculate/manufacturer.rb

@@ -5,7 +5,6 @@ require "digest"
 module Inoculate
   # Registers and builds dependency injection modules.
   # @todo singleton life cycle
-  # @todo instance life cycle
   # @todo thread singleton life cycle
   #
   # @since 0.1.0
@@ -28,49 +27,124 @@ module Inoculate
     #   manufacturer.transient(:sha1_hasher) { Digest::SHA1.new }
     #
     # @example With a Proc
-    #   manufacturer.transient(:sha1_hasher, -> { Digest::SHA1.new })
-    #
-    # @example With anything Callable
-    #   class HashingBuilder
-    #     def call = Digest::SHA1.new
-    #   end
-    #   manufacturer.transient(:sha1_hasher, HashingBuilder.new)
+    #   manufacturer.transient(:sha1_hasher, &-> { Digest::SHA1.new })
     #
     # @param name [Symbol, #to_sym] the dependency name which will be used to access it
-    # @param builder [#call] the callable to build the dependency
-    # @param block [Proc, nil] an alternative builder callable
+    # @param block [Block, Proc] a factory method to build the dependency
     #
-    # @raise [Errors::RequiresCallable] if no builder or block is provided
+    # @raise [Errors::RequiresCallable] if no block is provided
     # @raise [Errors::InvalidName] if the name is not a symbol, cannot be converted to a symbol,
     #                              or is not a valid attribute name
     # @raise [Errors::AlreadyRegistered] if the name has been registered previously
     #
     # @since 0.1.0
-    def transient(name, builder = nil, &block)
-      validate_builder_name name
+    def transient(name, &block)
+      register_blueprint(name, :transient, &block)
+    end
+
+    # Register an instance dependency.
+    #
+    # An instance dependency gets created once for each instance of a dependent class.
+    #
+    # @example With a block
+    #   manufacturer.instance(:sha1_hasher) { Digest::SHA1.new }
+    #
+    # @example With a Proc
+    #   manufacturer.instance(:sha1_hasher, &-> { Digest::SHA1.new })
+    #
+    # @param name [Symbol, #to_sym] the dependency name which will be used to access it
+    # @param block [Block, Proc] a factory method to build the dependency
+    #
+    # @raise [Errors::RequiresCallable] if no block is provided
+    # @raise [Errors::InvalidName] if the name is not a symbol, cannot be converted to a symbol,
+    #                              or is not a valid attribute name
+    # @raise [Errors::AlreadyRegistered] if the name has been registered previously
+    #
+    # @since 0.3.0
+    def instance(name, &block)
+      register_blueprint(name, :instance, &block)
+    end
+
+    # Register a singleton dependency.
+    #
+    # A singleton dependency gets created once.
+    #
+    # @example With a block
+    #   manufacturer.singleton(:sha1_hasher) { Digest::SHA1.new }
+    #
+    # @example With a Proc
+    #   manufacturer.singleton(:sha1_hasher, &-> { Digest::SHA1.new })
+    #
+    # @param name [Symbol, #to_sym] the dependency name which will be used to access it
+    # @param block [Block, Proc] a factory method to build the dependency
+    #
+    # @raise [Errors::RequiresCallable] if no block is provided
+    # @raise [Errors::InvalidName] if the name is not a symbol, cannot be converted to a symbol,
+    #                              or is not a valid attribute name
+    # @raise [Errors::AlreadyRegistered] if the name has been registered previously
+    #
+    # @since 0.4.0
+    def singleton(name, &block)
+      register_blueprint(name, :singleton, &block)
+    end
+
+    private
+
+    def register_blueprint(name, lifecycle, &block)
+      validate_dependency_name name
       raise Errors::AlreadyRegistered if @registered_blueprints.has_key? name
-      raise Errors::RequiresCallable unless builder.respond_to?(:call) || block
+      raise Errors::RequiresCallable if block.nil?
 
       blueprint_name = name.to_sym
       @registered_blueprints[blueprint_name] = {
-        lifecycle: :transient,
-        builder: builder || block,
-        accessor_module: build_module(blueprint_name, :transient, builder || block)
+        lifecycle: lifecycle,
+        factory: block,
+        accessor_module: build_module(blueprint_name, lifecycle, block)
       }
     end
 
-    private
+    def build_module(name, lifecycle, factory)
+      module_name = "I#{hash_name(name)}"
+      module_body =
+        case lifecycle
+        when :transient then build_transient(name, factory)
+        when :instance then build_instance(name, factory)
+        when :singleton then build_singleton(name, factory)
+        else raise ArgumentError, "Life cycle #{lifecycle} is not valid. Something has gone very wrong."
+        end
+
+      Providers.module_eval { const_set(module_name, module_body) }
+    end
+
+    def build_transient(name, factory)
+      Module.new do
+        private define_method(name) { factory.call }
+      end
+    end
 
-    def build_module(name, lifecycle, builder)
-      module_name = "I#{Digest::SHA1.hexdigest(name.to_s)}"
-      Providers.module_eval do
-        const_set(module_name, Module.new do
-          private define_method(name) { builder.call }
-        end)
+    def build_instance(name, factory)
+      cache_variable_name = "@icache_#{hash_name(name)}"
+      Module.new do
+        define_method(name) do
+          instance_variable_set(cache_variable_name, factory.call) unless instance_variable_defined?(cache_variable_name)
+          instance_variable_get(cache_variable_name)
+        end
+        private name
       end
     end
 
-    def validate_builder_name(name)
+    def build_singleton(name, factory)
+      cache_variable_name = "@@icache_#{hash_name(name)}"
+      Module.new do |mod|
+        define_method(name) do
+          mod.class_variable_set(cache_variable_name, factory.call) unless mod.class_variable_defined?(cache_variable_name)
+          mod.class_variable_get(cache_variable_name)
+        end
+        private name
+      end
+    end
+
+    def validate_dependency_name(name)
       raise Errors::InvalidName, "name must be a symbol or convert to one" unless name.respond_to? :to_sym
       begin
         Module.new { attr_reader name }
@@ -78,5 +152,9 @@ module Inoculate
         raise Errors::InvalidName, "name must be a valid attr_reader"
       end
     end
+
+    def hash_name(name)
+      Digest::SHA1.hexdigest(name.to_s)
+    end
   end
 end

data/lib/inoculate/version.rb

@@ -2,5 +2,5 @@
 
 module Inoculate
   # The library version.
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/sig/inoculate.rbs

@@ -6,9 +6,9 @@ module Inoculate
   end
 
   type callable = ^() -> untyped
-  type lifecycle_name = :transient
+  type lifecycle_name = :transient | :instance
   type builder_name = Symbol
-  type blueprint = { lifecycle: lifecycle_name, builder: callable, accessor_module: Module? }
+  type blueprint = { lifecycle: lifecycle_name, factory: callable, accessor_module: Module? }
 
   module Errors
     class Error < StandardError
@@ -32,13 +32,17 @@ module Inoculate
 
   class Manufacturer
     attr_reader registered_blueprints: Hash[builder_name, blueprint]
-    def transient: (builder_name | _ToSymbol, callable?) ?{ () -> void } -> void
+    def transient: (builder_name | _ToSymbol) { () -> void } -> void
+    def instance: (builder_name | _ToSymbol) { () -> void } -> void
+    def singleton: (builder_name | _ToSymbol) { () -> void } -> void
   end
 
   class Configurer
     def initialize: (Manufacturer) -> void
 
-    def transient: (builder_name | _ToSymbol, callable?) -> void
+    def transient: (builder_name | _ToSymbol) { () -> void } -> nil
+    def instance: (builder_name | _ToSymbol) { () -> void } -> nil
+    def singleton: (builder_name | _ToSymbol) { () -> void } -> nil
 
     private
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: inoculate
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Stephan Tarulli
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-10-12 00:00:00.000000000 Z
+date: 2022-10-13 00:00:00.000000000 Z
 dependencies: []
 description: |
   Inoculate is a small, thread-safe dependency injection library configured entirely with Ruby.