callme 0.5.0 → 0.6.0

data/lib/callme/{bean_metadata.rb → dep_metadata.rb}

@@ -1,30 +1,31 @@
-# Stores bean specific data: bean class, name,
-# scope and bean dependencies
-class Callme::BeanMetadata
-  attr_reader :name, :bean_class, :scope, :instance, :factory_method, :attrs
+# Stores dep specific data: dep class, name, contract,
+# scope and dep dependencies
+class Callme::DepMetadata
+  attr_reader :name, :dep_class, :scope, :instance, :factory_method, :attrs, :contract
 
   # Constructor
-  # @param name [Symbol] bean name
-  # @params options [Hash] includes bean class and scope
-  # @params &block [Proc] bean dependencies, has the following structure:
+  # @param name [Symbol] dep name
+  # @params options [Hash] includes dep class and scope
+  # @params &block [Proc] dep dependencies, has the following structure:
   #   do |c|
   #     attr :some_dependency, ref: :dependency_name
   #     arg  :another_dependency, ref: :another_dependency_name
   #   end
   # here attr means setter injection, arg means constructon injects
-  # +some_dependency+ is an attr_accessor defined in the bean class,
+  # +some_dependency+ is an attr_accessor defined in the dep class,
   # +ref+ specifies what dependency from container to use to set the attribute
   def initialize(name, options, &block)
     Callme::ArgsValidator.has_key!(options, :class)
 
     @name           = name
-    @bean_class     = options[:class]
+    @dep_class      = options[:class]
+    @contract       = options[:contract]
     @scope          = options[:scope] || :singleton
     @instance       = options[:instance].nil? ? true : options[:instance]
     @factory_method = options[:factory_method]
     @attrs          = []
 
-    fetch_attrs!(@bean_class)
+    fetch_attrs!(@dep_class)
 
     if block
       Dsl.new(@attrs).instance_exec(&block)
@@ -35,7 +36,7 @@ class Callme::BeanMetadata
     if klass.respond_to?(:_callme_injectable_attrs)
       klass._callme_injectable_attrs.each do |attr, options|
         options[:ref] ||= attr
-        @attrs << Callme::BeanMetadata::Attribute.new(attr, options)
+        @attrs << Callme::DepMetadata::Attribute.new(attr, options)
       end
     end
   end
@@ -44,6 +45,10 @@ class Callme::BeanMetadata
     !!@factory_method
   end
 
+  def has_contract?
+    !!@contract
+  end
+
   class Attribute
     attr_reader :name, :ref
 
@@ -60,11 +65,11 @@ class Callme::BeanMetadata
     end
 
     def attr(name, options)
-      @attrs << Callme::BeanMetadata::Attribute.new(name, options)
+      @attrs << Callme::DepMetadata::Attribute.new(name, options)
     end
 
     def arg(name, options)
-      @args << Callme::BeanMetadata::Attribute.new(name, options)
+      @args << Callme::DepMetadata::Attribute.new(name, options)
     end
   end
 end

data/lib/callme/deps_metadata_storage.rb

@@ -0,0 +1,32 @@
+# Storage of dep metadatas
+class Callme::DepsMetadataStorage
+  def initialize(dep_metadatas = {})
+    @dep_metadatas = dep_metadatas
+  end
+
+  # Finds dep metadata in storage by it's name
+  # @param name [Symbol] dep metadata name
+  # @return dep metadata
+  def by_name(name)
+    @dep_metadatas[name]
+  end
+
+  # Saves a given +dep_metadata+ to the storage
+  # @param dep_metadata [DepMetadata] dep metadata for saving
+  def put(dep_metadata)
+    @dep_metadatas[dep_metadata.name] = dep_metadata
+  end
+
+  def values
+    @dep_metadatas.values
+  end
+
+  def keys
+    @dep_metadatas.keys
+  end
+
+  # Creates an independent copy of this instance
+  def copy
+    self.class.new(@dep_metadatas.dup)
+  end
+end

data/lib/callme/errors.rb

@@ -1,10 +1,24 @@
 module Callme::Errors
   # Thrown when a service cannot be located by name.
-  class MissingBeanError < StandardError; end
+  class MissingDepError < StandardError; end
 
   # Thrown when a duplicate service is registered.
-  class DuplicateBeanError < StandardError; end
+  class DuplicateDepError < StandardError; end
 
-  # Thrown when an unsupported bean scope is specified.
+  # Thrown when an unsupported dep scope is specified.
   class UnsupportedScopeError < StandardError; end
+
+  class DependencyContractMissingMethodsException < StandardError; end
+
+  class DependencyContractInvalidParametersException < StandardError
+    def initialize(method, parameters)
+      @method = method
+      @parameters = parameters
+    end
+
+    def to_s
+      parameter_names = @parameters.join(', ')
+      "The method signature of method: '#{@method}' does not match the contract parameters: '#{parameter_names}'"
+    end
+  end
 end

data/lib/callme/inject.rb

@@ -1,36 +1,37 @@
-# Extend object with the bean injection mechanism
+# Extend object with the dep injection mechanism
 # Example of usage:
 # class Bar
 # end
 #
 # class Foo
+#   include Callme::Inject
 #   inject :bar
 #   or:
 #   inject :some_bar, ref: bar
 # end
 #
 # ioc_container[:foo].bar == ioc_container[:bar]
-class Object
-
-  class << self
-
-    def inject(dependency_name, options = {})
-      unless dependency_name.is_a?(Symbol)
-        raise ArgumentError, "dependency name should be a symbol"
+module Callme
+  module Inject
+    def self.included(base)
+      base.instance_eval do
+        def inject(dependency_name, options = {})
+          unless dependency_name.is_a?(Symbol)
+            raise ArgumentError, "dependency name should be a symbol"
+          end
+          unless options.is_a?(Hash)
+            raise ArgumentError, "second argument for inject method should be a Hash"
+          end
+          unless respond_to?(:_callme_injectable_attrs)
+            class_attribute :_callme_injectable_attrs
+            self._callme_injectable_attrs = { dependency_name => options.dup }
+          else
+            self._callme_injectable_attrs =
+              self._callme_injectable_attrs.merge(dependency_name => options.dup)
+          end
+          attr_accessor dependency_name
+        end
       end
-      unless options.is_a?(Hash)
-        raise ArgumentError, "second argument for inject method should be a Hash"
-      end
-      unless respond_to?(:_callme_injectable_attrs)
-        class_attribute :_callme_injectable_attrs
-        self._callme_injectable_attrs = { dependency_name => options.dup }
-      else
-        self._callme_injectable_attrs =
-          self._callme_injectable_attrs.merge(dependency_name => options.dup)
-      end
-      attr_accessor dependency_name
     end
-
   end
-
 end

data/lib/callme/scopes/prototype_scope.rb

@@ -1,25 +1,25 @@
-# Prototype scope instantiates new bean instance
-# on each +get_bean+ call
+# Prototype scope instantiates new dep instance
+# on each +get_dep+ call
 class Callme::Scopes::PrototypeScope
 
   # Constructon
-  # @param bean_factory bean factory
-  def initialize(bean_factory)
-    @bean_factory = bean_factory
+  # @param dep_factory dep factory
+  def initialize(dep_factory)
+    @dep_factory = dep_factory
   end
 
-  # Get new bean instance
-  # @param bean_metadata [BeanMetadata] bean metadata
-  # @returns bean instance
-  def get_bean(bean_metadata)
-    @bean_factory.create_bean_and_save(bean_metadata, {})
+  # Get new dep instance
+  # @param dep_metadata [DepMetadata] dep metadata
+  # @returns dep instance
+  def get_dep(dep_metadata)
+    @dep_factory.create_dep_and_save(dep_metadata, {})
   end
 
-  # Delete bean from scope,
-  # because Prototype scope doesn't store bean
+  # Delete dep from scope,
+  # because Prototype scope doesn't store dep
   # then do nothing here
   #
-  # @param bean_metadata [BeanMetadata] bean metadata
-  def delete_bean(bean_metadata)
+  # @param dep_metadata [DepMetadata] dep metadata
+  def delete_dep(dep_metadata)
   end
 end

data/lib/callme/scopes/request_scope.rb

@@ -1,33 +1,34 @@
 require 'request_store'
 
-# Request scope instantiates new bean instance
+# Request scope instantiates new dep instance
 # on each new HTTP request
 class Callme::Scopes::RequestScope
 
   # Constructon
-  # @param bean_factory bean factory
-  def initialize(bean_factory)
-    @bean_factory = bean_factory
+  # @param dep_factory dep factory
+  def initialize(dep_factory)
+    @dep_factory = dep_factory
   end
 
-  # Returns a bean from the +RequestStore+
+  # Returns a dep from the +RequestStore+
   # RequestStore is a wrapper for Thread.current
   # which clears it on each new HTTP request
   #
-  # @param bean_metadata [BeanMetadata] bean metadata
-  # @returns bean instance
-  def get_bean(bean_metadata)
-    RequestStore.store[:_callme_beans] ||= {}
-    if bean = RequestStore.store[:_callme_beans][bean_metadata.name]
-      bean
-    else
-     @bean_factory.create_bean_and_save(bean_metadata, RequestStore.store[:_callme_beans])
-    end
+  # @param dep_metadata [DepMetadata] dep metadata
+  # @returns dep instance
+  def get_dep(dep_metadata)
+    store[dep_metadata.name] || @dep_factory.create_dep_and_save(dep_metadata, store)
   end
 
-  # Delete bean from scope
-  # @param bean_metadata [BeanMetadata] bean metadata
-  def delete_bean(bean_metadata)
-    RequestStore.store[:_callme_beans].delete(bean_metadata.name)
+  # Delete dep from scope
+  # @param dep_metadata [DepMetadata] dep metadata
+  def delete_dep(dep_metadata)
+    store.delete(dep_metadata.name)
+  end
+
+  private
+
+  def store
+    RequestStore.store[:_callme_deps] ||= {}
   end
 end

data/lib/callme/scopes/singleton_scope.rb

@@ -1,29 +1,30 @@
-# Singleton scope returns the same bean instance
+# Singleton scope returns the same dep instance
 # on each call
 class Callme::Scopes::SingletonScope
 
   # Constructon
-  # @param bean_factory bean factory
-  def initialize(bean_factory)
-    @beans = {}
-    @bean_factory = bean_factory
+  # @param dep_factory dep factory
+  def initialize(dep_factory)
+    @dep_factory = dep_factory
   end
 
-  # Returns the same bean instance
+  # Returns the same dep instance
   # on each call
-  # @param bean_metadata [BeanMetadata] bean metadata
-  # @returns bean instance
-  def get_bean(bean_metadata)
-    if bean = @beans[bean_metadata.name]
-      bean
-    else
-      @bean_factory.create_bean_and_save(bean_metadata, @beans)
-    end
+  # @param dep_metadata [DepMetadata] dep metadata
+  # @returns dep instance
+  def get_dep(dep_metadata)
+    store[dep_metadata.name] || @dep_factory.create_dep_and_save(dep_metadata, store)
   end
 
-  # Delete bean from scope
-  # @param bean_metadata [BeanMetadata] bean metadata
-  def delete_bean(bean_metadata)
-    @beans.delete(bean_metadata.name)
+  # Delete dep from scope
+  # @param dep_metadata [DepMetadata] dep metadata
+  def delete_dep(dep_metadata)
+    store.delete(dep_metadata.name)
+  end
+
+  private
+
+  def store
+    @deps ||= {}
   end
 end

data/lib/callme/version.rb

@@ -1,3 +1,3 @@
 module Callme
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/spec/callme/container_spec.rb

@@ -11,17 +11,17 @@ describe Callme::Container do
   class Printer
   end
 
-  describe "bean definitions" do
+  describe "dep definitions" do
     let(:container) do
       container = Callme::Container.new
-      container.bean(:appender, class: Appender)
-      container.bean(:logger, class: Logger) do
+      container.dep(:appender, class: Appender)
+      container.dep(:logger, class: Logger) do
         attr :appender, ref: :appender
       end
-      container.bean(:printer, class: Printer, instance: false)
+      container.dep(:printer, class: Printer, instance: false)
       container
     end
-    it "should instanciate bean and it's dependencies" do
+    it "should instanciate dep and it's dependencies" do
       container[:logger].should be_a(Logger)
       container[:logger].appender.should be_a(Appender)
       container[:printer].should be(Printer)
@@ -33,46 +33,46 @@ describe Callme::Container do
     end
   end
 
-  describe "eager_load_bean_classes" do
+  describe "eager_load_dep_classes" do
     let(:container) do
       container = Callme::Container.new
-      container.bean(:appender, class: 'Appender')
-      container.bean(:logger, class: 'Logger') do
+      container.dep(:appender, class: 'Appender')
+      container.dep(:logger, class: 'Logger') do
         attr :appender, ref: :appender
       end
-      container.bean(:printer, class: 'Printer', instance: false)
+      container.dep(:printer, class: 'Printer', instance: false)
       container
     end
 
-    it "should eager load bean classes" do
-      container.eager_load_bean_classes
+    it "should eager load dep classes" do
+      container.eager_load_dep_classes
     end
   end
 
 
-  describe "#replace_bean" do
-    it "should replace bean definition" do
+  describe "#replace_dep" do
+    it "should replace dep definition" do
       container = Callme::Container.new
-      container.bean(:appender, class: Appender)
+      container.dep(:appender, class: Appender)
       container[:appender].should be_a(Appender)
 
-      container.replace_bean(:appender, class: Logger)
+      container.replace_dep(:appender, class: Logger)
       container[:appender].should be_a(Logger)
     end
   end
 
-  describe "passing bean definitions to container constructor" do
+  describe "passing dep definitions to container constructor" do
     let(:resource) do
       Proc.new do |c|
-        c.bean(:appender, class: 'Appender')
-        c.bean(:logger, class: Logger) do
+        c.dep(:appender, class: 'Appender')
+        c.dep(:logger, class: Logger) do
           attr :appender, ref: :appender
         end
       end
     end
 
-    it "should instanciate given bean definitions" do
-      container = Callme::Container.new_with_beans([resource])
+    it "should instanciate given dep definitions" do
+      container = Callme::Container.new_with_deps([resource])
       container[:logger].should be_a(Logger)
       container[:appender].should be_a(Appender)
     end
@@ -81,6 +81,7 @@ describe Callme::Container do
 
   describe "inheritance" do
     class Form
+      include Callme::Inject
       inject :validator
     end
 
@@ -100,11 +101,11 @@ describe Callme::Container do
 
     let(:container) do
       Callme::Container.new do |c|
-        c.bean(:circle,              class: Circle)
-        c.bean(:rectangle,           class: Rectangle)
-        c.bean(:validator,           class: Validator)
-        c.bean(:circle_validator,    class: CircleValidator)
-        c.bean(:rectangle_validator, class: RectangleValidator)
+        c.dep(:circle,              class: Circle)
+        c.dep(:rectangle,           class: Rectangle)
+        c.dep(:validator,           class: Validator)
+        c.dep(:circle_validator,    class: CircleValidator)
+        c.dep(:rectangle_validator, class: RectangleValidator)
       end
     end
 
@@ -114,8 +115,9 @@ describe Callme::Container do
     end
   end
 
-  describe "bean scopes" do
+  describe "dep scopes" do
     class ContactsService
+      include Callme::Inject
       inject :contacts_repository
       inject :contacts_validator
     end
@@ -126,13 +128,13 @@ describe Callme::Container do
 
     let(:container) do
       container = Callme::Container.new
-      container.bean(:contacts_repository, class: ContactsRepository, scope: :request)
-      container.bean(:contacts_service,    class: ContactsService,    scope: :singleton)
-      container.bean(:contacts_validator,  class: ContactsValidator,  scope: :prototype)
+      container.dep(:contacts_repository, class: ContactsRepository, scope: :request)
+      container.dep(:contacts_service,    class: ContactsService,    scope: :singleton)
+      container.dep(:contacts_validator,  class: ContactsValidator,  scope: :prototype)
       container
     end
 
-    it "should instanciate bean with :request scope on each request" do
+    it "should instanciate dep with :request scope on each request" do
       first_repo  = container[:contacts_service].contacts_repository
       second_repo = container[:contacts_service].contacts_repository
       first_repo.should == second_repo
@@ -141,7 +143,7 @@ describe Callme::Container do
       first_repo.should_not == third_repo
     end
 
-    it "should instanciate bean with :prototype scope on each call" do
+    it "should instanciate dep with :prototype scope on each call" do
       first_validator  = container[:contacts_service].contacts_validator
       second_validator = container[:contacts_service].contacts_validator
       first_validator.should_not == second_validator
@@ -161,21 +163,23 @@ describe Callme::Container do
 
     let(:container) do
       Callme::Container.new do |c|
-        c.bean :config, class: Test::ConfigsFactory, factory_method: :load_config
+        c.dep :config, class: Test::ConfigsFactory, factory_method: :load_config
       end
     end
 
-    it "should instantiate bean using factory method" do
+    it "should instantiate dep using factory method" do
       container[:config].should be_instance_of(Test::Config)
     end
   end
 
   describe "parent container" do
     class ContactBook
+      include Callme::Inject
       inject :contacts_repository
       inject :validator, ref: :contact_validator
     end
     class ContactBookService
+      include Callme::Inject
       inject :contacts_repository
       inject :validator, ref: :contact_validator
     end
@@ -192,20 +196,20 @@ describe Callme::Container do
 
     let(:parent){
       Callme::Container.new do |c|
-        c.bean(:contacts_repository,  class: ContactsRepository)
-        c.bean(:contact_validator,    class: ContactValidator)
-        c.bean(:contact_book,         class: ContactBook)
-        c.bean(:contact_book_service, class: "ContactBookService")
+        c.dep(:contacts_repository,  class: ContactsRepository)
+        c.dep(:contact_validator,    class: ContactValidator)
+        c.dep(:contact_book,         class: ContactBook)
+        c.dep(:contact_book_service, class: "ContactBookService")
       end
     }
 
     let(:container){
       Callme::Container.with_parent(parent) do |c|
-        c.bean(:contact_validator,    class: TestContactValidator)
+        c.dep(:contact_validator,    class: TestContactValidator)
       end
     }
 
-    it "works for direct beans" do
+    it "works for direct deps" do
       expect(container[:contact_validator]).to be_a(TestContactValidator)
       expect(container[:contact_book_service].validator).to be_a(TestContactValidator)
     end
@@ -216,7 +220,7 @@ describe Callme::Container do
 
     it "does not consider changes to parent" do
       expect(parent[:contact_book_service].validator).to be_a(ContactValidator)
-      parent.replace_bean(:contact_validator, class: AnotherTestContactValidator)
+      parent.replace_dep(:contact_validator, class: AnotherTestContactValidator)
       expect(parent[:contact_validator]).to be_a(AnotherTestContactValidator)
       parent.reset!
       expect(parent[:contact_book_service].validator).to be_a(AnotherTestContactValidator)
@@ -225,7 +229,7 @@ describe Callme::Container do
 
     it "changes in child container do not affect parent container" do
       expect(parent[:contact_book_service].validator).to be_a(ContactValidator)
-      container.replace_bean(:contact_validator, class: AnotherTestContactValidator)
+      container.replace_dep(:contact_validator, class: AnotherTestContactValidator)
       parent.reset!
       container.reset!
       expect(parent[:contact_validator]).to be_a(ContactValidator)