diftw 1.0.0 → 2.0.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed4f281eaa6b95e409c825895a500a9c9b6db4d8
-  data.tar.gz: 1e75e7a3742adcefceb5ac7eca10d3e419fff3d0
+  metadata.gz: 857aa566d69b0bd4d1ef8dc6ecefbc4f3a0b3cd0
+  data.tar.gz: d52f12033f704c5084848d754dc44910eaa6c083
 SHA512:
-  metadata.gz: e5c70d1c4b160b0f255d1b535e9546a405999395ab67500a92e09a573191139388c2fee91abef84886367fc10a7bce28ccff42b1ccf5271d319fa4a098205dd4
-  data.tar.gz: 62f45ba974d044141e9bab092f5c4c60daa1847b27955bd3cc31aeacf83d256ea501615420c599cf6bbad0a12c18817cf5f9662e8b7dbc534519d20bb307ebbd
+  metadata.gz: 7c6da96970981bee7c5b3c92ccec642fb28196dbdea5d56dc8b4b587df728582658cc6200c9cc6af60ba13fdafe6bf50c05eeaaca8f2dde39f74b3ef38694904
+  data.tar.gz: 32f4b052c953d33429cdbc68a3e93ad72b9891ee9f04694f0631db5dbbdb7f330d7ff05f204743da15aa5d3d6e653fda1a47976199c1c66e8d81b7ab0d09f78f

data/README.md

@@ -26,6 +26,11 @@ If your only concern is testing, mocks/stubs and `webmock` might be all you need
       factory :bar do
         OpenStruct.new(message: "Everyone will get a NEW version of this object")
       end
+
+      # inject dependencies into your dependency
+      factory :foobar, [:foo, :bar] do
+        OpenStruct.new(message: foo.message + bar.message)
+      end
     end
 
     # Or register things out here
@@ -33,9 +38,6 @@ If your only concern is testing, mocks/stubs and `webmock` might be all you need
       OpenStruct.new(message: "Bar")
     end
 
-    # Or use a Proc
-    DI.factory :xyz, -> { OpenStruct.new(message: "XYZ") }
-
 ## Lazy injection (by default)
 
     class Widget
@@ -97,7 +99,7 @@ This means you can re-register a dependency on a child injector, and *it* will b
 
     # Create your root injector and register :foo
     DI = DiFtw::Injector.new
-    DI.singleton :foo, -> { 'Foo' }
+    DI.singleton(:foo) { 'Foo' }
     
     class Widget
       include DI.inject :foo
@@ -133,7 +135,7 @@ This means you can re-register a dependency on a child injector, and *it* will b
     
     # But we could re-register/override :foo in Spline.injector, and all new
     # Spline instances would resolve :foo differently.
-    Spline.injector.singleton :foo, -> { 'Bar' }
+    Spline.injector.singleton(:foo) { 'Bar' }
     Spline.new.foo
     => 'Bar'
     # But DI and Widget.injector would be unchanged
@@ -143,7 +145,7 @@ This means you can re-register a dependency on a child injector, and *it* will b
     # We can go even further and override :foo in just one specific instance of Spline
     # NOTE This only works if you're using lazy injection (the default) AND if you haven't called #foo yet
     s = Spline.new
-    s.injector.singleton :foo, -> { 'Baz' }
+    s.injector.singleton(:foo) { 'Baz' }
     s.foo
     => 'Baz'
     # Other Spline instances will still get their override from Spline.injector
@@ -157,13 +159,13 @@ This means you can re-register a dependency on a child injector, and *it* will b
 
 To inject different dependencies in these environments, you have several options. You can simply re-register dependencies in your root injector:
 
-    DI.singleton :foo, -> { OpenStruct.new(message: 'Test Foo') }
+    DI.singleton(:foo) { OpenStruct.new(message: 'Test Foo') }
     
 And/Or you can use the parent-child injector features described above to great effect:
 
     before :each do
       # Give all MyService instances 'Test foo' as #foo
-      MyService.injector.singleton :foo, -> {
+      MyService.injector.singleton(:foo) {
         'Test foo'
       }
     end

data/lib/diftw.rb

@@ -1,4 +1,5 @@
 require 'diftw/injector'
+require 'diftw/provider'
 require 'diftw/singleton'
 require 'diftw/factory'
 require 'diftw/builder'

data/lib/diftw/factory.rb

@@ -17,7 +17,7 @@ module DiFtw
     # Return the value for the dependency by calling the registration Proc.
     #
     def resolve
-      @y.()
+      @y.call
     end
   end
 end

data/lib/diftw/injector.rb

@@ -12,17 +12,12 @@ module DiFtw
   #     Bar.new
   #   end
   #
-  #   # Or you can pass a Proc
-  #   DI.singleton :baz, -> { Baz.new }
-  #
   # Alternatively, you can pass a block to the initializer and register your depencies right inside it:
   #
   #   DI = DiFtw::Injector.new do
   #     singleton :foo do
   #       Foo.new
   #     end
-  #
-  #     singleton :bar, -> { Bar }
   #   end
   #
   class Injector
@@ -53,14 +48,14 @@ module DiFtw
     #     Foo
     #   end
     #
-    #   DI.singleton :bar, -> { Bar }
-    #
     # @param name [Symbol] name of the dependency
+    # @param deps [Array<Symbol>] Array of dependencies to inject into the provider block
     # @param y [Proc] the dependency wrapped in a Proc or block
     # @return [DiFtw::Injector] returns the Injector object
     # 
-    def singleton(name, y = nil, &block)
-      registry[name] = Singleton.new(y || block)
+    def singleton(name, deps = [], &y)
+      provider = Provider.new(self, name, y, deps)
+      registry[name] = Singleton.new(provider)
       self
     end
 
@@ -72,14 +67,14 @@ module DiFtw
     #     Foo
     #   end
     #
-    #   DI.factory :bar, -> { Bar }
-    #
     # @param name [Symbol] name of the dependency
+    # @param deps [Array<Symbol>] Array of dependencies to inject into the provider block
     # @param y [Proc] the dependency wrapped in a Proc or block
     # @return [DiFtw::Injector] returns the Injector object
     #
-    def factory(name, y = nil, &block)
-      registry[name] = Factory.new(y || block)
+    def factory(name, deps = [], &y)
+      provider = Provider.new(self, name, y, deps)
+      registry[name] = Factory.new(provider)
       self
     end
 

data/lib/diftw/provider.rb

@@ -0,0 +1,23 @@
+module DiFtw
+  #
+  # Class that provides a dependency via a "call" method. It may optionally depend on other dependencies,
+  # which will be available as methods inside the given Proc.
+  #
+  class Provider
+    #
+    # @param injector [DiFtw::Injection]
+    # @param name [Symbol]
+    # @param y [Proc]
+    # @param deps [Array<Symbol]
+    #
+    def initialize(injector, name, y, deps = [])
+      @name, @y = name, y
+      injector.inject_instance self, *deps if deps.any?
+    end
+
+    # Executes the proc and returns the dependency
+    def call
+      self.instance_exec(&@y)
+    end
+  end
+end

data/lib/diftw/singleton.rb

@@ -19,7 +19,7 @@ module DiFtw
     # will be cached and re-used for later injections. Yes, it's thread-safe.
     #
     def resolve
-      @val || @mutex.synchronize { @val ||= @y.() }
+      @val || @mutex.synchronize { @val ||= @y.call }
     end
   end
 end

data/lib/diftw/version.rb

@@ -1,4 +1,4 @@
 module DiFtw
   # Library version
-  VERSION = '1.0.0'.freeze
+  VERSION = '2.0.0.pre.rc1'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: diftw
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0.pre.rc1
 platform: ruby
 authors:
 - Jordan Hollinger
@@ -22,6 +22,7 @@ files:
 - lib/diftw/builder.rb
 - lib/diftw/factory.rb
 - lib/diftw/injector.rb
+- lib/diftw/provider.rb
 - lib/diftw/singleton.rb
 - lib/diftw/version.rb
 homepage: https://github.com/jhollinger/ruby-diftw
@@ -39,9 +40,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.2