diftw 0.4.0 → 1.0.0.pre.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 003ba4d7dfddcf1130c2dcc1a82b398265af7c5e
-  data.tar.gz: 290586529ebe1c70de998696f182c06cd6251a07
+  metadata.gz: 2cdc890fe9de411546dd8cdee3cbf7c7e3002475
+  data.tar.gz: 2eb8aeebfdc305b91a06f260e4eef43fb917c2e4
 SHA512:
-  metadata.gz: 34f2a2827ee113f6e847318c2b5315d25109901727c0a743fff22b07953aae7fdf4efb1e0300658b5dd3a784101e008469cd90d88d50e79747101df09284b09e
-  data.tar.gz: 6ddc67b51453af2ccc8b29ae2712c06b27c704716af93f2435e5bfc12ea476792b0b1a6acfd194995f36c54e15c7e3aa3668a1938f320d0cd254bef9e9007f6b
+  metadata.gz: 9d9f306c34f9870f76f8ebcba3d3fef1602fee927ca819499730cd8edddc0bd19c455abca01e46808965f3c46c94d3e9fe85b76c5f972ff44fc799d153cd5e6d
+  data.tar.gz: 677d79d8e34c7e9388a0757616666430be7fc5be9a5452bf9d35c81cd9bbba45f8166373f7bea268f9827599a9c0637d9f7315eeb9c3d0396c6241067b050d32

data/README.md

@@ -2,24 +2,22 @@
 
 Dependency Injection For The Win! A small, yet surprisingly powerful, dependency injection library for Ruby.
 
-**NOTE** This library is pre-1.0 and under active development. It's perfectly usable, but expect breaking API or behavior changes until 1.0.
-
 ### Why DI in Ruby?
 
 If your only concern is testing, mocks/stubs and `webmock` might be all you need. But if you're working on a large project that hooks into all kinds of enterprisey services, and those services aren't always available in dev/testing/staging, a dash of DI might be just the thing.
 
 ### Features
 
-* Dead-simple registration API
+* DI container w/dead-simple registration
 * Lazy injection (by default)
-* Inject into all instances, a single instance, a class, or a module
-* Injects singletons (by default)
+* Inject into each of a class's instances, a single instance, a class itself, or a module
+* Optionally injects singletons
 * Uses parent-child injectors for max flexibility
 * Threadsafe, except for registration
 
 ## Dead-simple registration API
 
-    # Create your root injector
+    # Create your root injector/container
     DI = DiFtw::Injector.new do
       # Register some dependencies in here
       register :foo do
@@ -88,18 +86,16 @@ Lazy injection is usually fine. But if it isn't, use `inject!`:
     puts SomeModule.baz.message
     => 'Baz'
 
-## Injects singletons (by default)
+## Optionally injects singletons
 
-    Widget.new.bar.object_id == Widget.new.bar.object_id
-    => true
-
-If you *don't* want your injector to return singletons (i.e. get a new copy each time you inject something), initialize your injector like this:
+    DI = DiFtw::Injector.new do
+      singleton :bar do
+        OpenStruct.new(message: 'Bar')
+      end
+    end
 
-    DI = DiFtw::Injector.new(singleton: false)
-    DI[:bar] = -> { OpenStruct.new(message: 'Bar') }
-    ...
     Widget.new.bar.object_id == Widget.new.bar.object_id
-    => false
+    => true
 
 Accessing injected singletons **is thread safe**. However, registering them is not.
 
@@ -107,7 +103,7 @@ Accessing injected singletons **is thread safe**. However, registering them is n
 
 This is **maybe the coolest part**. Each time you call `inject` (or `inject_instance`) you're creating a fresh, empty child `DiFtw::Injector`. It will recursively look up dependencies through the parent chain until it finds the nearest registration of that dependency.
 
-This means you can re-register a dependency on your child injector, and *it* will be injected instead of whatever is registered above it in the chain. Objects using sibling or parent injectors will remain unchanged, as they won't know about this registration override. Perhaps some examples are best.
+This means you can re-register a dependency on a child injector, and *it* will be injected instead of whatever is registered above it in the chain.
 
     # Create your root injector and register :foo
     DI = DiFtw::Injector.new
@@ -173,11 +169,7 @@ To inject different dependencies in these environments, you have several options
 
     DI[:foo] = -> { OpenStruct.new(message: 'Test Foo') }
     
-And you can use the parent-child injector features described above.
-
-### Injecting in before(:each)
-
-If you want to re-inject something into a class's injector in something like rspec's `before(:each)`:
+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

data/lib/diftw.rb

@@ -1,3 +1,4 @@
 require 'diftw/injector'
+require 'diftw/dependency'
 require 'diftw/builder'
 require 'diftw/version'

data/lib/diftw/dependency.rb

@@ -0,0 +1,38 @@
+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

data/lib/diftw/injector.rb

@@ -28,14 +28,10 @@ module DiFtw
   class Injector
     # @return [DiFtw::Injector] The parent injector, if any
     attr_reader :parent
-    # @return [Boolean] If true, the Injector injects singleton objects
-    attr_reader :singleton
     # @return [Hash] A Hash containing all registered depencies (as procs) keyed by Symbols
     attr_reader :registry
-    # @return [Hash] A Hash containing a Mutex for each dependency (only if singleton == true)
-    attr_reader :mutexes
 
-    protected :registry, :mutexes
+    protected :registry
     private :parent
 
     #
@@ -43,14 +39,8 @@ module DiFtw
     #
     #   DI = DiFtw::Injector.new
     #
-    # @param singleton [Boolean] If true, each dependency will only be initialized once. When false, it will be initialized each time it's injected.
-    #
-    def initialize(singleton: true, parent: nil, &registrator)
+    def initialize(parent: nil, &registrator)
       @registry, @parent = {}, parent
-      @singleton = parent ? parent.singleton : singleton
-      @mutexes = (parent ? parent.mutexes.keys : []).
-        inject({}) { |a, name| a[name] = Mutex.new; a }
-      @metamutex = Mutex.new
       instance_eval &registrator if registrator
     end
 
@@ -68,45 +58,47 @@ module DiFtw
     # @return [DiFtw::Injector] returns the Injector object
     #
     def register(name, y = nil, &block)
-      registry[name] = y || block
-      if singleton
-        instance_variable_set "@_singleton_#{name}", nil
-        mutexes[name] ||= Mutex.new
-      end
+      registry[name] = Dependency.new(y || block, singleton: false)
       self
     end
 
     #
-    # Register a new dependency by passing a Proc or a block.
+    # 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[:foo] = -> { Foo }
+    #   DI.singleton :bar, -> { Bar }
     #
     # @param name [Symbol] name of the dependency
-    # @param y [Proc] the dependency wrapped in a Proc
-    #
-    def []=(name, y)
-      register name, y
+    # @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)
+      self
     end
 
     #
-    # Fetches a dependency by name (calls the Proc/block). If this is a Singleton injector,
-    # the same object will be returned each time. Otherwise a new one will be returned each time.
-    #
-    # An application will probably never want to call this directly.
+    # Fetches a dependency by name (calls the Proc/block).
     #
     # @return whatever the Proc/block returns
     #
-    def [](name)
-      if singleton
-        var = "@_singleton_#{name}"
-        instance_variable_get(var) || mutex(name).synchronize {
-          instance_variable_get(var) || instance_variable_set(var, resolve!(name))
-        }
+    def fetch(name)
+      if parent.nil?
+        registry.fetch(name).resolve
+      elsif registry.has_key? name
+        registry[name].resolve
       else
-        resolve! name
+        parent[name]
       end
     end
 
+    alias_method :[], :fetch
+
     #
     # Unregisters the dependency from this injector instance. This means requests for this dependency
     # will continue on up the chain.
@@ -116,9 +108,6 @@ module DiFtw
     #
     def delete(name)
       registry.delete name
-      if singleton
-        instance_variable_set "@_singleton_#{name}", nil
-      end
       self
     end
 
@@ -155,32 +144,5 @@ module DiFtw
       mod = DiFtw::Builder.injector_module self, dependencies
       instance.singleton_class.send :include, mod
 	end
-
-    protected
-
-    #
-    # Recursively look up a dependency
-    #
-    # @param dependency [Symbol] name of dependency
-    # @return [Proc]
-    #
-    def resolve!(dependency)
-      if parent.nil?
-        registry.fetch(dependency).call
-      elsif registry.has_key? dependency
-        registry[dependency].call
-      else
-        parent[dependency]
-      end
-    end
-
-    private
-
-    def mutex(name)
-      return mutexes[name] unless mutexes[name].nil?
-      @metamutex.synchronize {
-        mutexes[name] = Mutex.new
-      }
-    end
   end
 end

data/lib/diftw/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: diftw
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.0.0.pre.rc1
 platform: ruby
 authors:
 - Jordan Hollinger
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-07-25 00:00:00.000000000 Z
+date: 2017-06-13 00:00:00.000000000 Z
 dependencies: []
 description: A small dependency injection library for Ruby
 email: jordan.hollinger@gmail.com
@@ -20,6 +20,7 @@ files:
 - README.md
 - lib/diftw.rb
 - lib/diftw/builder.rb
+- lib/diftw/dependency.rb
 - lib/diftw/injector.rb
 - lib/diftw/version.rb
 homepage: https://github.com/jhollinger/ruby-diftw
@@ -37,14 +38,13 @@ 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.4.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Dependency Injection For The Win!
 test_files: []
-has_rdoc: