jerry 1.0.1 → 2.0.0

data/lib/jerry.rb

@@ -1,53 +1,41 @@
 require 'jerry/version'
+require 'jerry/errors'
 require 'jerry/config'
 
 # Inversion of Control container.
 #
-# This class is in charge of bootstrapping your application. This is done by defining {Jerry::Config configs}.
+# This class is in charge of bootstrapping your application. This is done by
+# defining {Jerry::Config configs}.
 #
-# @example
-#   class MyConfig < Jerry::Config
-#     component(:app) { MyApp.new }
+# @example Basic usage
+#   class FooConfig < Jerry::Config
+#     # ...
 #   end
-#   jerry = Jerry.new MyConfig.new
-#   jerry.rig :app #=> #<MyApp:...>
+#
+#   class BarConfig < Jerry::Config
+#     # ...
+#   end
+#
+#   jerry = Jerry.new FooConfig.new, BarConfig.new
+#   jerry[SomeClass] #=> #<Someclass:...>
 class Jerry
-  # Indicated that an error occurred while rigging a component
-  class RigError < StandardError; end
-
-  # @param [Jerry::Config] configs Configs used to rig components. Multiple config can be given. If two configs
-  #   define the same component, the later config will have priority.
+  # @param configs [Array<Jerry::Config>] configurations describing how to wire
+  #   your application
   def initialize(*configs)
-    @index = {}
-
-    configs.each { |config| self << config }
-  end
-
-  # Load a config
-  #
-  # @param [Jerry::Config] config Config to be loaded. If the loaded config defines a component already defined
-  #   by another config, the component from the new config will take priority.
-  def <<(config)
-    components = config.components
-    components.each { |component| @index[component] = config }
-    config.jerry = self
-  end
-
-  # Rigs a component
-  #
-  # @param [Symbol] component Component to rig.
-  # @return The component requested
-  # @raise [Jerry::RigError] when the requested component does not exist
-  def rig(component)
-    raise RigError, "could not find component #{component}" unless knows? component
+    configs.each { |conf| conf.jerry = self }
 
-    @index[component].public_send component
+    @configs = configs
   end
 
-  # Checks if a component exists
-  #
-  # @param [Symbol] component component to check
-  def knows?(component)
-    @index.has_key? component
+  # @param key what to provide
+  # @return an insance of the sepcified key provided by one of the configs
+  # @raise [Jerry::InstantiationError] if can't instanciate key
+  def [](key)
+    config = @configs.find { |conf| conf.knows? key }
+    if config
+      config[key]
+    else
+      fail Jerry::InstantiationError, "Can't find #{key} in any config"
+    end
   end
 end

data/spec/class_provider_spec.rb

@@ -0,0 +1,109 @@
+require 'jerry/class_provider'
+
+describe Jerry::ClassProvider do
+  let(:jerry) { double 'jerry' }
+  let(:config) { double 'config' }
+  let(:klass) { dummy_class }
+
+  def dummy_class
+    Class.new do
+      define_method(:initialize) { |*| }
+    end
+  end
+
+  describe '#call' do
+    it 'should return an instance of the class' do
+      provider = Jerry::ClassProvider.new klass, []
+      instance = double 'instance'
+      allow(klass).to receive(:new).and_return(instance)
+
+      expect(provider.call jerry, config).to eq instance
+    end
+
+    it 'should pass constructor arguments in the right order' do
+      provider = Jerry::ClassProvider.new klass, [
+        proc { 'fi' }, proc { 'fo' }, proc { 'fum' }]
+
+      expect(klass).to receive(:new).with('fi', 'fo', 'fum')
+
+      provider.call jerry, config
+    end
+  end
+
+  describe 'with a class argument' do
+    it 'should get the instance from jerry' do
+      arg_klass = dummy_class
+      provider = Jerry::ClassProvider.new klass, [arg_klass]
+
+      expect(jerry).to receive(:[]).with(arg_klass)
+
+      provider.call jerry, config
+    end
+
+    it 'should pass the instance from jerry to the constructor' do
+      provider = Jerry::ClassProvider.new klass, [dummy_class]
+      instance = double 'instance'
+      allow(jerry).to receive(:[]).and_return(instance)
+
+      expect(klass).to receive(:new).with(instance)
+
+      provider.call jerry, config
+    end
+  end
+
+  describe 'with a symbol argument' do
+    it 'should get the instance from jerry' do
+      provider = Jerry::ClassProvider.new klass, [:foobar]
+
+      expect(jerry).to receive(:[]).with(:foobar)
+
+      provider.call jerry, config
+    end
+
+    it 'should pass the instance from jerry to the constructor' do
+      provider = Jerry::ClassProvider.new klass, [:foobar]
+      instance = double 'instance'
+      allow(jerry).to receive(:[]).with(:foobar).and_return(instance)
+
+      expect(klass).to receive(:new).with(instance)
+
+      provider.call jerry, config
+    end
+  end
+
+  describe 'with callable argument' do
+    it 'should call the callable' do
+      expect do |callable|
+        provider = Jerry::ClassProvider.new klass, [callable.to_proc]
+        provider.call jerry, config
+      end.to yield_control
+    end
+
+    it 'should pass the result of the callable to the constructor' do
+      instance = double 'instance'
+      provider = Jerry::ClassProvider.new klass, [proc { instance }]
+
+      expect(klass).to receive(:new).with(instance)
+
+      provider.call jerry, config
+    end
+
+    it 'should pass the jerry and config instance to the proc' do
+      expect do |callable|
+        provider = Jerry::ClassProvider.new klass, [callable.to_proc]
+        provider.call jerry, config
+      end.to yield_with_args(jerry, config)
+    end
+
+    it 'should call the proc in the context of the config' do
+      config = double 'config'
+      config.instance_eval { @stuff = 'something private' }
+      callable = proc { @stuff }
+      provider = Jerry::ClassProvider.new klass, [callable]
+
+      expect(klass).to receive(:new).with('something private')
+
+      provider.call jerry, config
+    end
+  end
+end

data/spec/config_spec.rb

@@ -1,172 +1,192 @@
-require 'rspec'
 require 'jerry/config'
+require 'fixtures/house'
 
 describe Jerry::Config do
-  let(:klass) {Class.new(Jerry::Config)}
+  let(:config_klass) { Class.new Jerry::Config }
+  let(:config) { config_klass.new }
+  let(:jerry) { double 'jerry' }
 
-  describe 'subclass' do
-    it 'should respond to all inherited class methods' do
-      expect(klass).to respond_to :components
-      expect(klass).to respond_to :component
-    end
+  before do
+    config.jerry = jerry
   end
 
-  describe '#components' do
-    it 'should call the class contents method' do
-      instance = klass.new
-
-      expect(klass).to receive(:components).and_return([:something])
+  describe '::bind' do
+    it 'should create a class provider' do
+      klass = double 'class'
+      args = [Class.new, :foobar, -> { 'stuff' }]
+      expect(Jerry::ClassProvider).to receive(:new).with(klass, args)
 
-      expect(instance.components).to eq([:something])
+      Class.new Jerry::Config do
+        bind klass, args
+      end
     end
-  end
 
-  describe '#rig' do
-    it 'should call rig on the previously set jerry' do
-      jerry = double('jerry')
-      config = klass.new
-      config.jerry = jerry
+    it 'should default ctor_args to empty array' do
+      expect(Jerry::ClassProvider).to receive(:new).with(anything, [])
+
+      Class.new Jerry::Config do
+        bind Class.new
+      end
+    end
 
-      expect(jerry).to receive(:rig).with(:target)
+    it 'should use the class to identify the provider' do
+      klass = Class.new
+      config = Class.new Jerry::Config do
+        bind klass
+      end
 
-      config.instance_eval { rig :target }
+      expect(config.providers).to have_key klass
     end
 
-    it 'should return the result from the jerry rig method' do
-      jerry = double('jerry')
-      allow(jerry).to receive(:rig).with(anything).and_return 42
-      config = klass.new
-      config.jerry = jerry
+    it 'should return the class' do
+      klass = Class.new
+      thing = nil
 
-      expect(config.instance_eval { rig :something }).to eq(42)
+      Class.new Jerry::Config do
+        thing = bind klass
+      end
+
+      expect(thing).to eq klass
     end
   end
 
-  describe '#knows?' do
-    it 'should call the knows? method on the previously set jerry' do
-      jerry = double('jerry')
-      config = klass.new
-      config.jerry = jerry
+  describe '::named_bind' do
+    it 'should create a class provider' do
+      klass = double 'class'
+      args = [Class.new, :foobar, proc { 'stuff' }]
+      expect(Jerry::ClassProvider).to receive(:new).with(klass, args)
 
-      expect(jerry).to receive(:knows?).with(:target)
+      Class.new Jerry::Config do
+        named_bind :stuff, klass, args
+      end
+    end
 
-      config.instance_eval { knows? :target }
+    it 'should default ctor args to emtpy array' do
+      expect(Jerry::ClassProvider).to receive(:new).with(anything, [])
+
+      Class.new Jerry::Config do
+        named_bind :thing, Class.new
+      end
     end
 
-    it 'should return the results from the jerry knows? method' do
-      jerry = double('jerry')
-      allow(jerry).to receive(:knows?).with(anything).and_return true
-      config = klass.new
-      config.jerry = jerry
+    it 'should use the given key to store the provider' do
+      config = Class.new Jerry::Config do
+        named_bind :the_name, Class.new
+      end
 
-      expect(config.instance_eval { knows? :something }).to be_truthy
+      expect(config.providers).to have_key :the_name
     end
-  end
 
-  describe 'class methods' do
-    describe '#component' do
-      it 'should create a method with the given name' do
-        klass.component(:my_component) {}
+    it 'should return the key' do
+      thing = nil
 
-        expect(klass.new).to respond_to(:my_component)
+      Class.new Jerry::Config do
+        thing = named_bind :foobar, Class.new
       end
 
-      it 'should add the name to the list of components' do
-        klass.component(:target) {}
+      expect(thing).to eq :foobar
+    end
+  end
 
-        expect(klass.components).to include(:target)
+  describe '::singleton' do
+    it 'should always use the same instance' do
+      config = Class.new Jerry::Config do
+        singleton named_bind :thing, Class.new
       end
 
-      it 'should raise an error when scope is unknown' do
-        expect{klass.component(:target, scope: :not_a_thing) {}}.to raise_error(Jerry::ComponentError)
+      jerry = Jerry.new config.new
+      thing1 = jerry[:thing]
+      thing2 = jerry[:thing]
+
+      expect(thing1).to equal thing2
+    end
+
+    it 'should only instantiate the class once' do
+      klass = double 'class', new: double('instance')
+      config = Class.new Jerry::Config do
+        singleton bind klass
       end
 
-      it 'should raise an error when block is missing' do
-        expect{klass.component :target}.to raise_error(Jerry::ComponentError)
+      expect(klass).to receive(:new).once
+
+      jerry = Jerry.new config.new
+      2.times { jerry[klass] }
+    end
+  end
+
+  describe '#[]' do
+    it 'should get the provider instance from ::bind' do
+      instance = double 'instance'
+      klass = double 'class', new: instance
+
+      config_klass.class_eval do
+        bind klass
       end
 
-      describe 'defined method' do
-        it 'should have the right self set' do
-          klass.component(:_self) { self }
-          instance = klass.new
-
-          expect(instance._self).not_to be_a Class
-          expect(instance._self).to be_a klass
-          expect(instance._self).to eq(instance)
-        end
-
-        context 'with scope set to :single' do
-          it 'should only call the block once' do
-            call_count = 0
-            klass.component(:target, scope: :single) {call_count += 1}
-            instance = klass.new
-
-            3.times {instance.target}
-
-            expect(call_count).to eq(1)
-          end
-
-          it 'should keep returning the first created component' do
-            call_count = 0
-            klass.component(:target, scope: :single) {call_count += 1}
-            instance = klass.new
-
-            expect(instance.target).to eq(1)
-            expect(instance.target).to eq(1)
-            expect(instance.target).to eq(1)
-          end
-        end
-
-        context 'with scope set to :instance' do
-          it 'should call the block every time' do
-            call_count = 0
-            klass.component(:target, scope: :instance) {call_count += 1}
-            instance = klass.new
-
-            3.times {instance.target}
-
-            expect(call_count).to eq(3)
-          end
-
-          it 'should return a new instance every time' do
-            call_count = 0
-            klass.component(:target, scope: :instance) {call_count += 1}
-            instance = klass.new
-
-            expect(instance.target).to eq(1)
-            expect(instance.target).to eq(2)
-            expect(instance.target).to eq(3)
-          end
-        end
-
-        context 'with no scope' do
-          it 'should only call the block once' do
-            call_count = 0
-            klass.component(:target) {call_count += 1}
-            instance = klass.new
-
-            3.times {instance.target}
-
-            expect(call_count).to eq(1)
-          end
-
-          it 'should keep returning the first created component' do
-            call_count = 0
-            klass.component(:target) {call_count += 1}
-            instance = klass.new
-
-            expect(instance.target).to eq(1)
-            expect(instance.target).to eq(1)
-            expect(instance.target).to eq(1)
-          end
-        end
+      expect(config[klass]).to eq instance
+    end
+
+    it 'should pass jerry to the provider' do
+      provider = double 'provider'
+      config_klass.send(:providers)[:foobar] = provider
+
+      expect(provider).to receive(:call).with(jerry, anything)
+
+      config[:foobar]
+    end
+
+    it 'should pass config instance to the provider' do
+      provider = double 'provider'
+      config_klass.providers[:something] = provider
+
+      expect(provider).to receive(:call).with(anything, config)
+
+      config[:something]
+    end
+
+    it 'should fail when provider is missing' do
+      expect { config[:not_there] }.to raise_error(Jerry::InstantiationError)
+    end
+
+    it 'should wrap errors from the provider' do
+      provider = double 'provider'
+      allow(provider).to receive(:call)
+        .and_raise(RuntimeError, 'something blew up')
+      config_klass.providers[:failing] = provider
+
+      expect { config[:failing] }
+        .to raise_error(Jerry::InstantiationError) do |e|
+        expect(e.cause.message).to eq 'something blew up'
       end
     end
 
-    describe '#components' do
-      it 'should default to an empty array' do
-        expect(klass.components).to eq([])
+    it 'should set self to config instance for all procs in spec' do
+      klass = Class.new do
+        attr_reader :thing
+        define_method(:initialize) { |thing| @thing = thing }
+      end
+      config_klass = Class.new(Jerry::Config) do
+        define_method(:initialize) { @foobar = 'something private' }
+        bind klass, [proc { @foobar }]
       end
+      config = config_klass.new
+      config.jerry = jerry
+
+      instance = config[klass]
+      expect(instance.thing).to eq 'something private'
+    end
+  end
+
+  describe '#knows?' do
+    it 'should be true if key is in providers' do
+      key = double 'some key'
+      config_klass.providers[key] = double 'some provider'
+
+      expect(config.knows? key).to be true
+    end
+
+    it 'should be false if key is not known' do
+      expect(config.knows? double('some unknown key')).to be false
     end
   end
-end
+end

data/spec/error_spec.rb

@@ -0,0 +1,23 @@
+describe Jerry::Error do
+  def raise_error_with_cause
+    fail 'Something went wrong'
+  rescue RuntimeError
+    raise Jerry::Error, 'wrapping error'
+  end
+
+  it 'should record the causing exception when there is one' do
+    expect { raise_error_with_cause }.to raise_error(Jerry::Error) do |ex|
+      expect(ex.cause.message).to eq 'Something went wrong'
+    end
+  end
+
+  it 'should not record the causing exception when there is none' do
+    expect { fail Jerry::Error }.to raise_error(Jerry::Error) do |ex|
+      expect(ex.cause).to be_nil
+    end
+  end
+
+  it 'should have a message' do
+    expect { fail Jerry::Error, ':(' }.to raise_error(Jerry::Error, ':(')
+  end
+end

data/spec/examples_spec.rb

@@ -0,0 +1,120 @@
+require 'jerry'
+require 'fixtures/house'
+require 'fixtures/db_app'
+require 'fixtures/shopping_cart'
+require 'fixtures/shopping_cart_config'
+require 'fixtures/multi_db_app'
+
+describe Jerry do
+  it 'should wire dependencies' do
+    HousingModule = Class.new(Jerry::Config) do
+      bind House, [Door, Window]
+      bind Window, []
+      bind Door, []
+    end
+
+    jerry = Jerry.new HousingModule.new
+
+    house = jerry[House]
+
+    expect(house).to be_a House
+    expect(house.window).to be_a Window
+    expect(house.door).to be_a Door
+  end
+
+  it 'should allow the use of procs to wire settings' do
+    AppConfig = Class.new Jerry::Config do
+      def initialize(database_uri)
+        @database_uri = database_uri
+      end
+
+      bind DbApplication, [Database]
+      bind Database, [proc { @database_uri }]
+    end
+
+    jerry = Jerry.new AppConfig.new('mongodb://localhost:27017')
+    app = jerry[DbApplication]
+
+    expect(app).to be_a DbApplication
+    expect(app.db).to be_a Database
+    expect(app.db.uri).to eq 'mongodb://localhost:27017'
+  end
+
+  it 'should support multiple configs' do
+    jerry = Jerry.new(
+      ShoppingCart::DatabaseConfig.new,
+      ShoppingCart::ApplicationConfig.new,
+      ShoppingCart::UserConfig.new,
+      ShoppingCart::ProductConfig.new,
+      ShoppingCart::ShoppingCartConfig.new
+    )
+
+    app = jerry[ShoppingCart::Application]
+
+    expect(app).to be_a ShoppingCart::Application
+
+    expect(app.user_controller).to be_a ShoppingCart::UserController
+    expect(app.product_controller).to be_a ShoppingCart::ProductController
+    expect(app.shopping_cart_controller).to \
+      be_a ShoppingCart::ShoppingCartController
+
+    expect(app.user_controller.user_service).to be_a ShoppingCart::UserService
+    expect(app.product_controller.product_service).to \
+      be_a ShoppingCart::ProductService
+    expect(app.shopping_cart_controller.shopping_cart_service).to \
+      be_a ShoppingCart::ShoppingCartService
+
+    expect(app.user_controller.user_service.db).to be_a ShoppingCart::Database
+    expect(app.product_controller.product_service.db).to \
+      be_a ShoppingCart::Database
+    expect(app.shopping_cart_controller.shopping_cart_service.db).to \
+      be_a ShoppingCart::Database
+
+    shopping_cart_service = app.shopping_cart_controller.shopping_cart_service
+    expect(shopping_cart_service.user_service).to be_a ShoppingCart::UserService
+    expect(shopping_cart_service.product_service).to \
+      be_a ShoppingCart::ProductService
+  end
+
+  it 'should support wiring one class in multiple ways through naming' do
+    jerry = Jerry.new MultiDbApp::Config.new('db://foo', 'db://bar')
+
+    app = jerry[MultiDbApp::Application]
+
+    expect(app.foo_db.uri).to eq 'db://foo'
+    expect(app.bar_db.uri).to eq 'db://bar'
+  end
+
+  it 'should wire the same class multiple times with multiple names' do
+    klass = Class.new do
+      attr_reader :str
+      define_method(:initialize) { |str| @str = str }
+    end
+    config = Class.new Jerry::Config do
+      named_bind :foo, klass, [proc { 'foo' }]
+      named_bind :bar, klass, [proc { 'bar' }]
+    end
+    jerry = Jerry.new config.new
+
+    foo = jerry[:foo]
+    bar = jerry[:bar]
+
+    expect(foo).to be_a klass
+    expect(foo.str).to eq 'foo'
+    expect(bar).to be_a klass
+    expect(bar.str).to eq 'bar'
+  end
+
+  it 'should always wire the same instance when using singleton' do
+    klass = Class.new
+    config = Class.new Jerry::Config do
+      singleton bind klass
+    end
+    jerry = Jerry.new config.new
+
+    alfa = jerry[klass]
+    bravo = jerry[klass]
+
+    expect(alfa).to equal bravo
+  end
+end

data/spec/fixtures/db_app.rb

@@ -0,0 +1,17 @@
+# A database connector that connects to a given uri
+class Database
+  attr_reader :uri
+
+  def initialize(uri)
+    @uri = uri
+  end
+end
+
+# An application that uses a database
+class DbApplication
+  attr_reader :db
+
+  def initialize(db)
+    @db = db
+  end
+end