callme 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22eae5e35215e5eed4a7876f1bdac5b8f8f9bcdb
-  data.tar.gz: 734e00afe63b56af60134a224acc0489ae09d481
+  metadata.gz: 9f73aca55d583eee628366c833117fbb17be432f
+  data.tar.gz: e057e62c608d928460886bf84ccb8d3ebb31f0dd
 SHA512:
-  metadata.gz: ab1b440d21c6f30ee6ff3d95b89d5462485bf5505a468994ee1712117dc3e5c2e6b019b6e17660313f6ecbb7937f1c539e286a98a3464e0cb5d8f091f6def3cd
-  data.tar.gz: be2243ddbedb38520e29e85e652db9f2a09a168d99ae89dec6c30e2e8e57925f2e95be4e35094eb342d87f0adc93137bfdcdd008d6782c7fae096667c852d55b
+  metadata.gz: bc3406c637301c9813dfbe08cbc5c874778439f63e51800d2b9593f2fd4b8690b957463a73cce7f43d84a968db339e8244412b50c31dc53a1e35deaf0f814f61
+  data.tar.gz: 4352b39b8c1224621e30a58d28e3797b62ec7c519183090441aacf072b70c29f0227399d85768d09632852d3c671c6c197fb8ffe447eba1267463719d01c0682

data/CHANGELOG.md

@@ -0,0 +1,13 @@
+## 0.6 (2017-06-27)
+
+Features:
+
+  - rename `beans` to `deps` (names are important!)
+  - no more global `Object.inject` method, use `include Callme::Inject` instead
+
+
+## 0.5 (2017-06-26)
+
+Features:
+
+  - rename project from `ioc_rb` to `callme`, to pick up the stalled development

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    callme (0.5.0)
+    callme (0.6.0)
       request_store
 
 GEM

data/README.md

@@ -1,4 +1,4 @@
-# Callme [![Build Status](https://travis-ci.org/mindreframer/callme.png)](https://travis-ci.org/mindreframer/callme) [![Code Climate](https://codeclimate.com/github/mindreframer/callme.png)](https://codeclimate.com/github/mindreframer/callme)
+# Callme [![Build Status](https://travis-ci.org/mindreframer/callme.svg)](https://travis-ci.org/mindreframer/callme) [![Code Climate](https://codeclimate.com/github/mindreframer/callme.svg)](https://codeclimate.com/github/mindreframer/callme)
 
 
 
@@ -30,11 +30,11 @@ logger.info('some message')
 ```
 
 Callme eliminates the manual injection step and injects dependencies by itself.
-To use it you need to instantiate Callme::Container and pass dependency definitions(we call them beans) to it:
+To use it you need to instantiate Callme::Container and pass dependency definitions(we call them deps) to it:
 ```ruby
 container = Callme::Container.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
@@ -48,6 +48,7 @@ logger.info('some message')
 To simplify injection Callme allows you specify dependencies inside of your class:
 ```ruby
 class Logger
+  include Callme::Inject
   inject :appender
 
   def info(message)
@@ -58,11 +59,11 @@ end
 class Appender
 end
 ```
-With `inject` keyword you won't need to specify class dependencies in bean definition:
+With `inject` keyword you won't need to specify class dependencies in dep definition:
 ```ruby
 container = Callme::Container.new do |c|
-  c.bean(:appender, class: Appender)
-  c.bean(:logger, class: Logger)
+  c.dep(:appender, class: Appender)
+  c.dep(:logger, class: Logger)
 end
 ```
 
@@ -70,14 +71,16 @@ end
 
 ## Inheriting from other containers
 Quite often you will want to selectively override some parts of the system, use `Callme::Container.with_parent` to
-create a new container with all the beans copied from the parent container.
+create a new container with all the deps copied from the parent container.
 
 ```ruby
 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
@@ -92,22 +95,22 @@ class AnotherTestContactValidator
 end
 
 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
 puts parent[:contact_book_service].validator.class
 #=> ContactValidator
 
 testcontainer = Callme::Container.with_parent(parent) do |c|
-  c.bean(:contact_validator,    class: TestContactValidator)
+  c.dep(:contact_validator,    class: TestContactValidator)
 end
 puts testcontainer[:contact_book_service].validator.class
 #=> TestContactValidator
 
 third = Callme::Container.with_parent(parent) do |c|
-  c.bean(:contact_validator,    class: AnotherTestContactValidator)
+  c.dep(:contact_validator,    class: AnotherTestContactValidator)
 end
 
 puts third[:contact_book_service].validator.class
@@ -139,7 +142,7 @@ Or install it yourself as:
 
 # TODO
 1. Constructor based injection
-2. Scope registration, refactor BeanFactory. Callme:Container.register_scope(SomeScope)
+2. Scope registration, refactor DepFactory. Callme:Container.register_scope(SomeScope)
 3. Write documentation with more examples
 
 ## Author

data/lib/callme.rb

@@ -1,4 +1,19 @@
 require 'ext/vendored_activesupport'
 require 'callme/version'
+
+require 'callme/const_loaders/native'
+require 'callme/args_validator'
+require 'callme/contract_validator'
+require 'callme/errors'
 require 'callme/inject'
 require 'callme/container'
+
+require 'callme/dep_metadata'
+require 'callme/deps_metadata_storage'
+
+require 'callme/scopes'
+require 'callme/scopes/singleton_scope'
+require 'callme/scopes/prototype_scope'
+require 'callme/scopes/request_scope'
+
+require 'callme/dep_factory'

data/lib/callme/const_loaders/active_support.rb

@@ -1,6 +1,7 @@
 module Callme::ConstLoaders
   module ActiveSupport
     def self.load_const(const_name)
+      return const_name if const_name.is_a?(Class)
       ::ActiveSupport::Inflector.constantize(const_name)
     end
   end

data/lib/callme/const_loaders/native.rb

@@ -1,6 +1,7 @@
 module Callme::ConstLoaders
   module Native
     def self.load_const(const_name)
+      return const_name if const_name.is_a?(Class)
       const_name.split('::').inject(Object) do |mod, const_part|
         mod.const_get(const_part)
       end

data/lib/callme/container.rb

@@ -1,34 +1,27 @@
-require 'callme/errors'
-require 'callme/args_validator'
-require 'callme/bean_metadata'
-require 'callme/beans_metadata_storage'
-require 'callme/bean_factory'
-require 'callme/const_loaders/native'
-
 module Callme
 
   # Callme::Container is the central data store for registering objects
   # used for dependency injection. Users register classes by
-  # providing a name and a class to create the object(we call them beans). Beans
+  # providing a name and a class to create the object(we call them deps). Deps
   # may be retrieved by asking for them by name (via the [] operator)
   class Container
     DEFAULT_CONST_LOADER = Callme::ConstLoaders::Native
 
     # Constructor
-    # @param resources [Array] array of procs with container's beans definitions
-    # @param &block [Proc] optional proc with container's beans definitions
+    # @param resources [Array] array of procs with container's deps definitions
+    # @param &block [Proc] optional proc with container's deps definitions
     def initialize(const_loader = DEFAULT_CONST_LOADER, &block)
-      @const_loader           = const_loader
-      @beans_metadata_storage = Callme::BeansMetadataStorage.new
-      @bean_factory           = Callme::BeanFactory.new(const_loader, @beans_metadata_storage)
+      @const_loader          = const_loader
+      @deps_metadata_storage = Callme::DepsMetadataStorage.new
+      @dep_factory           = Callme::DepFactory.new(const_loader, @deps_metadata_storage)
 
       block.call(self) if block_given?
     end
 
     # Evaluates the given array of blocks on the container instance
-    # what adds new bean definitions to the container
-    # @param resources [Array] array of procs with container's beans definitions
-    def self.new_with_beans(resources, const_loader = DEFAULT_CONST_LOADER)
+    # what adds new dep definitions to the container
+    # @param resources [Array] array of procs with container's deps definitions
+    def self.new_with_deps(resources, const_loader = DEFAULT_CONST_LOADER)
       Callme::ArgsValidator.is_array!(resources, :resources)
 
       self.new(const_loader).tap do |container|
@@ -39,69 +32,67 @@ module Callme
     end
 
     def self.with_parent(parent_container, &block)
-      const_loader           = parent_container.instance_variable_get("@const_loader")
-      beans_metadata_storage = parent_container.instance_variable_get("@beans_metadata_storage").copy
-      container              = self.new(const_loader)
+      const_loader          = parent_container.instance_variable_get("@const_loader")
+      deps_metadata_storage = parent_container.instance_variable_get("@deps_metadata_storage").copy
+      container             = self.new(const_loader)
       container.instance_eval do
-        @beans_metadata_storage = beans_metadata_storage
-        @bean_factory           = Callme::BeanFactory.new(const_loader, beans_metadata_storage)
+        @deps_metadata_storage = deps_metadata_storage
+        @dep_factory           = Callme::DepFactory.new(const_loader, deps_metadata_storage)
       end
       block.call(container) if block_given?
       container
     end
 
-    # Registers new bean in container
-    # @param bean_name [Symbol] bean name
-    # @param options [Hash] includes bean class and bean scope
-    # @param &block [Proc] the block  which describes bean dependencies,
-    #                      see more in the BeanMetadata
-    def bean(bean_name, options, &block)
-      Callme::ArgsValidator.is_symbol!(bean_name, :bean_name)
+    # Registers new dep in container
+    # @param dep_name [Symbol] dep name
+    # @param options [Hash] includes dep class and dep scope
+    # @param &block [Proc] the block  which describes dep dependencies,
+    #                      see more in the DepMetadata
+    def dep(dep_name, options, &block)
+      Callme::ArgsValidator.is_symbol!(dep_name, :dep_name)
       Callme::ArgsValidator.is_hash!(options, :options)
 
-      bean = Callme::BeanMetadata.new(bean_name, options, &block)
-      @beans_metadata_storage.put(bean)
+      dep = Callme::DepMetadata.new(dep_name, options, &block)
+      @deps_metadata_storage.put(dep)
     end
 
-    # Registers new bean in container and replace existing instance if it's instantiated
-    # @param bean_name [Symbol] bean name
-    # @param options [Hash] includes bean class and bean scope
-    # @param &block [Proc] the block  which describes bean dependencies,
-    #                      see more in the BeanMetadata
-    def replace_bean(bean_name, options, &block)
-      if @bean_factory.get_bean(bean_name)
-        @bean_factory.delete_bean(bean_name)
+    # Registers new dep in container and replace existing instance if it's instantiated
+    # @param dep_name [Symbol] dep name
+    # @param options [Hash] includes dep class and dep scope
+    # @param &block [Proc] the block  which describes dep dependencies,
+    #                      see more in the DepMetadata
+    def replace_dep(dep_name, options, &block)
+      if @dep_factory.get_dep(dep_name)
+        @dep_factory.delete_dep(dep_name)
       end
-      bean(bean_name, options, &block)
+      dep(dep_name, options, &block)
     end
 
     def reset!
-      @bean_factory = Callme::BeanFactory.new(@const_loader, @beans_metadata_storage)
+      @dep_factory = Callme::DepFactory.new(@const_loader, @deps_metadata_storage)
     end
 
-    # Returns bean instance from the container
-    # by the specified bean name
-    # @param name [Symbol] bean name
-    # @return bean instance
+    # Returns dep instance from the container
+    # by the specified dep name
+    # @param name [Symbol] dep name
+    # @return dep instance
     def [](name)
-      Callme::ArgsValidator.is_symbol!(name, :bean_name)
-      return @bean_factory.get_bean(name)
+      Callme::ArgsValidator.is_symbol!(name, :dep_name)
+      return @dep_factory.get_dep(name)
     end
 
     def keys
-      @beans_metadata_storage.keys
+      @deps_metadata_storage.keys
     end
 
-    # Load defined in bean classes
+    # Load defined in dep classes
     # this is needed for production usage
     # for eager loading
-    def eager_load_bean_classes
-      @beans_metadata_storage.bean_classes.each do |bean_class|
-        if !bean_class.is_a?(Class)
-          @const_loader.load_const(bean_class)
-        end
+    def eager_load_dep_classes
+      @deps_metadata_storage.values.each do |dep_metadata|
+        @const_loader.load_const(dep_metadata.dep_class)
+        @const_loader.load_const(dep_metadata.contract) if dep_metadata.contract
       end
     end
-
   end
 end

data/lib/callme/contract_validator.rb

@@ -0,0 +1,39 @@
+module Callme
+  # inspired by https://github.com/Sage/sinject/blob/master/lib/sinject/container.rb#L127
+  class ContractValidator
+    def validate(dependency_class, contract_class, const_loader)
+      contract_class = const_loader.load_const(contract_class) if contract_class.is_a?(String)
+      #get the methods defined for the contract
+      contract_methods = (contract_class.instance_methods - Object.instance_methods)
+      #get the methods defined for the dependency
+      dependency_methods = (dependency_class.instance_methods - Object.instance_methods)
+      #calculate any methods specified in the contract that are not specified in the dependency
+      missing_methods = contract_methods - dependency_methods
+
+      if !missing_methods.empty?
+        raise Callme::Errors::DependencyContractMissingMethodsException.new({
+            dep: dependency_class,
+            contract: contract_class,
+            missing: missing_methods
+        })
+      end
+
+      validate_methods(dependency_class, contract_class, contract_methods)
+    end
+
+    private
+
+    def validate_methods(dependency_class, contract_class, contract_methods)
+      contract_methods.each do |method|
+        #contract method parameters
+        cmp = contract_class.instance_method(method).parameters
+        #dependency method parameters
+        dmp = dependency_class.instance_method(method).parameters
+
+        if cmp != dmp
+          raise Callme::Errors::DependencyContractInvalidParametersException.new(method, cmp)
+        end
+      end
+    end
+  end
+end

data/lib/callme/dep_factory.rb

@@ -0,0 +1,119 @@
+# Instantiates deps according to their scopes
+class Callme::DepFactory
+  attr_reader :const_loader
+
+  # Constructor
+  # @param deps_metadata_storage [DepsMetadataStorage] storage of dep metadatas
+  def initialize(const_loader, deps_metadata_storage)
+    @const_loader           = const_loader
+    @deps_metadata_storage  = deps_metadata_storage
+    @singleton_scope        = Callme::Scopes::SingletonScope.new(self)
+    @prototype_scope        = Callme::Scopes::PrototypeScope.new(self)
+    @request_scope          = Callme::Scopes::RequestScope.new(self)
+  end
+
+  # Get dep from the container by it's +name+.
+  # According to the dep scope it will be newly created or returned already
+  # instantiated dep
+  # @param [Symbol] dep name
+  # @return dep instance
+  # @raise MissingDepError if dep with the specified name is not found
+  def get_dep(name)
+    dep_metadata = @deps_metadata_storage.by_name(name)
+    unless dep_metadata
+      raise Callme::Errors::MissingDepError, "Dep with name :#{name} is not defined"
+    end
+    get_dep_with_metadata(dep_metadata)
+  end
+
+  # Get dep by the specified +dep metadata+
+  # @param [DepMetadata] dep metadata
+  # @return dep instance
+  def get_dep_with_metadata(dep_metadata)
+    get_scope_by_metadata(dep_metadata).get_dep(dep_metadata)
+  end
+
+  # Create new dep instance according
+  # to the specified +dep_metadata+
+  # @param [DepMetadata] dep metadata
+  # @return dep instance
+  # @raise MissingDepError if some of dep dependencies are not found
+  def create_dep_and_save(dep_metadata, deps_storage)
+    if dep_metadata.dep_class.is_a?(Class)
+      dep_class = dep_metadata.dep_class
+    else
+      dep_class = const_loader.load_const(dep_metadata.dep_class)
+      dep_metadata.fetch_attrs!(dep_class)
+    end
+    dep = dep_metadata.instance ? dep_class.new : dep_class
+
+    if dep_metadata.has_contract?
+      contract_validator.validate(dep_class, dep_metadata.contract, const_loader)
+    end
+
+    if dep_metadata.has_factory_method?
+      set_dep_dependencies(dep, dep_metadata)
+      dep = dep.send(dep_metadata.factory_method)
+      deps_storage[dep_metadata.name] = dep
+    else
+      # put to container first to prevent circular dependencies
+      deps_storage[dep_metadata.name] = dep
+      set_dep_dependencies(dep, dep_metadata)
+    end
+
+    dep
+  end
+
+  # Delete dep from the container by it's +name+.
+  # @param [Symbol] dep name
+  # @raise MissingDepError if dep with the specified name is not found
+  def delete_dep(name)
+    dep_metadata = @deps_metadata_storage.by_name(name)
+    unless dep_metadata
+      raise Callme::Errors::MissingDepError, "Dep with name :#{name} is not defined"
+    end
+    get_scope_by_metadata(dep_metadata).delete_dep(dep_metadata)
+  end
+
+  private
+
+  def set_dep_dependencies(dep, dep_metadata)
+    dep_metadata.attrs.each do |attr|
+      dep_metadata = @deps_metadata_storage.by_name(attr.ref)
+      unless dep_metadata
+        raise Callme::Errors::MissingDepError, "Dep with name :#{attr.ref} is not defined, check #{dep.class}"
+      end
+      case dep_metadata.scope
+      when :singleton
+        dep.send("#{attr.name}=", get_dep(attr.ref))
+      when :prototype
+        dep.instance_variable_set(:@_callme_dep_factory, self)
+        dep.define_singleton_method(attr.name) do
+          @_callme_dep_factory.get_dep(attr.ref)
+        end
+      when :request
+        dep.instance_variable_set(:@_callme_dep_factory, self)
+        dep.define_singleton_method(attr.name) do
+          @_callme_dep_factory.get_dep(attr.ref)
+        end
+      end
+    end
+  end
+
+  def get_scope_by_metadata(dep_metadata)
+    case dep_metadata.scope
+    when :singleton
+      @singleton_scope
+    when :prototype
+      @prototype_scope
+    when :request
+      @request_scope
+    else
+      raise Callme::Errors::UnsupportedScopeError, "Dep with name :#{dep_metadata.name} has unsupported scope :#{dep_metadata.scope}"
+    end
+  end
+
+  def contract_validator
+    Callme::ContractValidator.new
+  end
+end