diftw 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 621429df0a88505d46bff336d29bb4cf4196726d
+  data.tar.gz: 52fbcdcc3013037ac707f08053fd8465a90f8bc6
+SHA512:
+  metadata.gz: e0ca2d926827c97501bbad7a38fc0ba2c7f0626b25a5e82a52161febe84ce02f759e3a04e84f61812ade709fcb6677de98802ff378ee3b4776fcb262227508e4
+  data.tar.gz: 6cd4cf04d662607d0ecfce83396501dbe44c34096ad7329d70cc537d8e09cc0c4bbbb71d07c9c7c250bf3df6d57f1549d5cebadd7df76cb2ab0cd180d0eebe86

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2016 Jordan Hollinger
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,86 @@
+# DiFtw
+
+Dependency Injection For The Win! A small gem for simple, yet flexible, dependency injection in Ruby.
+
+Some say you don't need DI in Ruby. Perhaps. Others say you don't need a DI *library* in Ruby. Probably true, but only in the pedantic sense that you don't need a DI library for *any* language. But I'll take a nice, idiomatic DI library over "just manually pass in every dependency to all your constructors!" any day. I couldn't find one, so I wrote this.
+
+## Basic Use
+
+    # Create your injector
+    Injector = DiFtw::Injector.new do
+      # Register some dependencies
+      register :foo do
+        OpenStruct.new(message: "Foo")
+      end
+    end
+
+    # Or register them like this
+    Injector.register :bar do
+      OpenStruct.new(message: "Bar")
+    end
+
+    # Or with a lambda
+    Injector[:baz] = -> { OpenStruct.new(message: "Baz") }
+
+    # Inject some dependencies into your class
+    class Widget
+      include Injector.inject(:foo, :bar)
+      
+      def initialize(random_arg)
+        # Unlike most DI, it doesn't hijack your initializer! Because Ruby!!1!
+        @random_arg = random_arg
+      end
+    end
+
+    # Now they're instance methods!
+    widget = Widget.new
+    puts widget.bar.message
+    => "Bar"
+
+## Singletons By Default
+
+By default the injector injects singletons. Observe:
+
+    widget1, widget2 = Widget.new, Widget.new
+    widget1.bar.object_id == widget1.bar.object_id
+    => true
+    widget1.bar.object_id == widget2.bar.object_id
+    => true
+
+If you *don't* want your injector to return singletons (i.e. get a new copy each time you inject), initialize your injector like this:
+
+    Injector = DiFtw::Injector.new(singleton: false)
+    Injector[:bar] = -> { OpenStruct.new(message: 'Bar') }
+    ...
+    widget1, widget2 = Widget.new, Widget.new
+    widget1.bar.object_id == widget1.bar.object_id
+    => true
+    widget1.bar.object_id == widget2.bar.object_id
+    => false
+
+Accessing injected singletons **is thread safe**. However, registering them is not.
+
+## Lazy, Nested Dependencies
+
+    # Define your class and tell it to inject :ab into instances
+    class Spline
+      include Injector.inject(:ab)
+    end
+    
+    # Init a Spline instance. Doesn't matter that :ab isn't registered; just don't call spline.ab yet.
+    spline = Spline.new
+
+    # Register :ab, which uses :a and :b. The order you register them in doesn't matter.
+    Injector[:ab] = -> { Injector[:a] + Injector[:b] }
+    Injector[:a] = -> { 'A' }
+    Injector[:b] = -> { 'B' }
+
+    # The :ab dependency isn't actually injected until .ab is called!
+    puts spline.ab
+    => 'AB'
+
+## DI in tests
+
+    # Presumably your injector is already initialized.
+    # Simply re-register the dependencies you need for your tests.
+    Injector[:foo] = -> { OpenStruct.new(message: 'Test Foo') }

data/lib/diftw.rb

@@ -0,0 +1,2 @@
+require 'diftw/injector'
+require 'diftw/version'

data/lib/diftw/injector.rb

@@ -0,0 +1,145 @@
+#
+# Dependency Injection For The Win!
+#
+module DiFtw
+  #
+  # The Injector class. Create an instance to start registering and injecting dependencies.
+  #
+  #   DI = DiFtw::Injector.new
+  #
+  #   # You can call register on the Injector object
+  #   DI.register :bar do
+  #     Bar.new
+  #   end
+  #
+  #   # Or you can assign a Proc to the Injector object like a Hash
+  #   DI[: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
+  #       Foo.new
+  #     end
+  #
+  #     register(:bar) { Bar }
+  #   end
+  #
+  class Injector
+    # @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
+
+    private :registry, :mutexes
+
+    #
+    # Instantiate a new Injector.
+    #
+    #   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, &registrator)
+      @registry, @mutexes = {}, {}
+      @singleton = singleton
+      instance_eval &registrator if registrator
+    end
+
+    #
+    # Register a new dependency by passing a Proc or a block.
+    #
+    #   DI.register :foo do
+    #     Foo
+    #   end
+    #
+    #   DI.register :bar, -> { Bar }
+    #
+    # @param name [Symbol] name of the dependency
+    # @param y [Proc] the dependency wrapped in a Proc or block
+    # @return [Injector] returns the Injector object
+    #
+    def register(name, y = nil, &block)
+      registry[name] = y || block
+      mutexes[name] = Mutex.new if singleton
+      self
+    end
+
+    #
+    # Register a new dependency by passing a Proc or a block.
+    #
+    #   DI[:foo] = -> { Foo }
+    #
+    # @param name [Symbol] name of the dependency
+    # @param y [Proc] the dependency wrapped in a Proc
+    #
+    def []=(name, y)
+      register name, y
+    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.
+    #
+    # @return whatever the Proc/block returns
+    #
+    def [](name)
+      if singleton
+        var = "@_singleton_#{name}"
+        instance_variable_get(var) || mutexes[name].synchronize {
+          instance_variable_get(var) || instance_variable_set(var, registry.fetch(name).call)
+        }
+      else
+        registry.fetch(name).call
+      end
+    end
+
+    #
+    # Creates and returns a new Module which contains instance methods for all the dependencies you specified.
+    # Simply include this module in your class, and all it's instances will have their dependencies injected.
+    #
+    #   class Widget
+    #     include DI.inject(:foo, :bar)
+    #   end
+    #
+    # @param dependencies [Symbol] All dependency names you want to inject.
+    #
+    def inject(*dependencies)
+      injector_module.tap do |mod|
+        mod._diftw_injector = self
+        mod._diftw_dependencies = dependencies
+      end
+    end
+
+    private
+
+    #
+    # Builds a new module that, when included in a class, defines instance methods for each dependecy.
+    #
+    # @return a new module
+    #
+    def injector_module
+      Module.new do
+        class << self
+          attr_accessor :_diftw_injector, :_diftw_dependencies
+        end
+
+        def self.included(base)
+          di_mod = self
+          base.class_eval do
+            di_mod._diftw_dependencies.each do |dep|
+              define_method dep do
+                var = "@_diftw_#{dep}"
+                instance_variable_get(var) || instance_variable_set(var, di_mod._diftw_injector[dep])
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/diftw/version.rb

@@ -0,0 +1,4 @@
+module DiFtw
+  # Library version
+  VERSION = '0.0.1'.freeze
+end

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: diftw
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jordan Hollinger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-01 00:00:00.000000000 Z
+dependencies: []
+description: A small dependency injection library for Ruby
+email: jordan.hollinger@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/diftw.rb
+- lib/diftw/injector.rb
+- lib/diftw/version.rb
+homepage: https://github.com/jhollinger/ruby-diftw
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Dependency Injection For The Win!
+test_files: []