diftw 1.0.0.pre.rc1 → 1.0.0.pre.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2cdc890fe9de411546dd8cdee3cbf7c7e3002475
-  data.tar.gz: 2eb8aeebfdc305b91a06f260e4eef43fb917c2e4
+  metadata.gz: 2fdc140e5795f103a584d7a7799acd59e40000e3
+  data.tar.gz: 03e40f06fb27bc8e20ecdc03711bb8043dc75de6
 SHA512:
-  metadata.gz: 9d9f306c34f9870f76f8ebcba3d3fef1602fee927ca819499730cd8edddc0bd19c455abca01e46808965f3c46c94d3e9fe85b76c5f972ff44fc799d153cd5e6d
-  data.tar.gz: 677d79d8e34c7e9388a0757616666430be7fc5be9a5452bf9d35c81cd9bbba45f8166373f7bea268f9827599a9c0637d9f7315eeb9c3d0396c6241067b050d32
+  metadata.gz: ec92e112aec09c21bcafe39a73a8b9aa623aa2917a26ca730e4047d68a5d8c4fbd0ef8061e0f59290931ec07cc287ab102e5a391ffd0daccce9b51fdfe98ae2a
+  data.tar.gz: c3e1f46d4b45018dbcf5289acba1362e5f54f2a4d0f83c06de8dd099cbcedb5f1bca42905c2cb363820d5de5eedc28e61ff6e1d2dbac0ad8ce210505f33b97c6

data/README.md

@@ -1,4 +1,4 @@
-# DiFtw
+# DiFtw [![Build Status](https://travis-ci.org/jhollinger/ruby-diftw.svg?branch=master)](https://travis-ci.org/jhollinger/ruby-diftw)
 
 Dependency Injection For The Win! A small, yet surprisingly powerful, dependency injection library for Ruby.
 
@@ -11,27 +11,30 @@ If your only concern is testing, mocks/stubs and `webmock` might be all you need
 * DI container w/dead-simple registration
 * Lazy injection (by default)
 * Inject into each of a class's instances, a single instance, a class itself, or a module
-* Optionally injects singletons
+* Inject singletons or factories
 * Uses parent-child injectors for max flexibility
-* Threadsafe, except for registration
+* Threadsafe, after registration
 
 ## Dead-simple registration API
 
     # Create your root injector/container
     DI = DiFtw::Injector.new do
-      # Register some dependencies in here
-      register :foo do
-        OpenStruct.new(message: "Foo")
+      singleton :foo do
+        OpenStruct.new(message: "Everyone will get this same object")
+      end
+
+      factory :bar do
+        OpenStruct.new(message: "Everyone will get a NEW version of this object")
       end
     end
 
-    # Or register them out here
-    DI.register :bar do
+    # Or register things out here
+    DI.singleton :zorp do
       OpenStruct.new(message: "Bar")
     end
 
-    # Or register them with procs
-    DI[:baz] = -> { OpenStruct.new(message: "Baz") }
+    # Or use a Proc
+    DI.factory :xyz, -> { OpenStruct.new(message: "XYZ") }
 
 ## Lazy injection (by default)
 
@@ -107,7 +110,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[:foo] = -> { 'Foo' }
+    DI.singleton :foo, -> { 'Foo' }
     
     class Widget
       include DI.inject :foo
@@ -143,7 +146,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[:foo] = -> { 'Bar' }
+    Spline.injector.singleton :foo, -> { 'Bar' }
     Spline.new.foo
     => 'Bar'
     # But DI and Widget.injector would be unchanged
@@ -153,7 +156,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[:foo] = -> { 'Baz' }
+    s.injector.singleton :foo, -> { 'Baz' }
     s.foo
     => 'Baz'
     # Other Spline instances will still get their override from Spline.injector
@@ -167,13 +170,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[: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[:foo] = -> {
+      MyService.injector.singleton :foo, -> {
         'Test foo'
       }
     end

data/lib/diftw.rb

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

data/lib/diftw/factory.rb

@@ -0,0 +1,23 @@
+module DiFtw
+  #
+  # A dependency that will be re-created every time it's injected.
+  #
+  class Factory
+    #
+    # A new dependency.
+    #
+    # @param y [Proc] returns the dependency
+    #
+    def initialize(y)
+      @y = y
+      @val = nil
+    end
+
+    #
+    # Return the value for the dependency by calling the registration Proc.
+    #
+    def resolve
+      @y.()
+    end
+  end
+end

data/lib/diftw/injector.rb

@@ -8,21 +8,21 @@ module DiFtw
   #   DI = DiFtw::Injector.new
   #
   #   # You can call register on the Injector object
-  #   DI.register :bar do
+  #   DI.singleton :bar do
   #     Bar.new
   #   end
   #
-  #   # Or you can assign a Proc to the Injector object like a Hash
-  #   DI[:baz] = -> { Baz.new }
+  #   # 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
-  #     register :foo do
+  #     singleton :foo do
   #       Foo.new
   #     end
   #
-  #     register(:bar) { Bar }
+  #     singleton :bar, -> { Bar }
   #   end
   #
   class Injector
@@ -41,44 +41,45 @@ module DiFtw
     #
     def initialize(parent: nil, &registrator)
       @registry, @parent = {}, parent
-      instance_eval &registrator if registrator
+      instance_eval(&registrator) if registrator
     end
 
     #
-    # Register a new dependency by passing a Proc or a block.
-    #
-    #   DI.register :foo do
+    # Register a new dependency as a singleton. The proc will only be called
+    # the first time, then the returned value will be stored and returned for
+    # subsequent injections. Threadsafe.
+    # 
+    #   DI.singleton :foo do
     #     Foo
     #   end
     #
-    #   DI.register :bar, -> { Bar }
+    #   DI.singleton :bar, -> { Bar }
     #
     # @param name [Symbol] name of the dependency
     # @param y [Proc] the dependency wrapped in a Proc or block
     # @return [DiFtw::Injector] returns the Injector object
-    #
-    def register(name, y = nil, &block)
-      registry[name] = Dependency.new(y || block, singleton: false)
+    # 
+    def singleton(name, y = nil, &block)
+      registry[name] = Singleton.new(y || block)
       self
     end
 
     #
-    # Register a new dependency as a singleton. The proc will only be called
-    # the first time, then the returned value will be stored and returned for
-    # subsequent injections. Threadsafe.
-    # 
-    #   DI.singleton :foo do
+    # Register a new dependency by passing a Proc or a block. Each time you
+    # inject it, the block/Proc will be re-run and you'll get the result.
+    #
+    #   DI.factory :foo do
     #     Foo
     #   end
     #
-    #   DI.singleton :bar, -> { Bar }
+    #   DI.factory :bar, -> { Bar }
     #
     # @param name [Symbol] name of the dependency
     # @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] = Dependency.new(y || block, singleton: true)
+    #
+    def factory(name, y = nil, &block)
+      registry[name] = Factory.new(y || block)
       self
     end
 

data/lib/diftw/singleton.rb

@@ -0,0 +1,25 @@
+module DiFtw
+  #
+  # Class representing an injected dependency that's only created once.
+  #
+  class Singleton
+    #
+    # A new dependency.
+    #
+    # @param y [Proc] returns the dependency
+    #
+    def initialize(y)
+      @y = y
+      @val = nil
+      @mutex = Mutex.new
+    end
+
+    #
+    # Return the value for the dependency. If this is the first access, the injected value
+    # will be cached and re-used for later injections. Yes, it's thread-safe.
+    #
+    def resolve
+      @val || @mutex.synchronize { @val ||= @y.() }
+    end
+  end
+end

data/lib/diftw/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: diftw
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.rc1
+  version: 1.0.0.pre.rc2
 platform: ruby
 authors:
 - Jordan Hollinger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-13 00:00:00.000000000 Z
+date: 2017-09-09 00:00:00.000000000 Z
 dependencies: []
 description: A small dependency injection library for Ruby
 email: jordan.hollinger@gmail.com
@@ -20,8 +20,9 @@ files:
 - README.md
 - lib/diftw.rb
 - lib/diftw/builder.rb
-- lib/diftw/dependency.rb
+- lib/diftw/factory.rb
 - lib/diftw/injector.rb
+- lib/diftw/singleton.rb
 - lib/diftw/version.rb
 homepage: https://github.com/jhollinger/ruby-diftw
 licenses:

data/lib/diftw/dependency.rb

@@ -1,38 +0,0 @@
-module DiFtw
-  #
-  # Class representing an injected dependency.
-  #
-  class Dependency
-    # @return [Proc] proc that returns the dependency
-    attr_reader :y
-    # @return [Boolean] whether or not this depdency is a singleton
-    attr_reader :singleton
-    # @return [Mutex] the mutex for accessing the Singleton
-    attr_reader :mutex
-
-    #
-    # A new dependency.
-    #
-    # @param y [Proc] returns the dependency
-    # @param singleton [Boolean] if true, the Proc will only be called the first time the dep is injected.
-    #
-    def initialize(y, singleton:)
-      @y = y
-      @singleton = singleton
-      @mutex = Mutex.new if singleton
-    end
-
-    #
-    # Return the value for the dependency. If this is a singleton, the value will
-    # only be initialized on the first call (thread safe). Otherwise, the proc will
-    # called each time.
-    #
-    def resolve
-      if singleton
-        @val || mutex.synchronize { @val ||= y.() }
-      else
-        y.()
-      end
-    end
-  end
-end