callme 0.5.0

data/lib/callme/inject.rb

@@ -0,0 +1,36 @@
+# Extend object with the bean injection mechanism
+# Example of usage:
+# class Bar
+# end
+#
+# class Foo
+#   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"
+      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

@@ -0,0 +1,25 @@
+# Prototype scope instantiates new bean instance
+# on each +get_bean+ call
+class Callme::Scopes::PrototypeScope
+
+  # Constructon
+  # @param bean_factory bean factory
+  def initialize(bean_factory)
+    @bean_factory = bean_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, {})
+  end
+
+  # Delete bean from scope,
+  # because Prototype scope doesn't store bean
+  # then do nothing here
+  #
+  # @param bean_metadata [BeanMetadata] bean metadata
+  def delete_bean(bean_metadata)
+  end
+end

data/lib/callme/scopes/request_scope.rb

@@ -0,0 +1,33 @@
+require 'request_store'
+
+# Request scope instantiates new bean instance
+# on each new HTTP request
+class Callme::Scopes::RequestScope
+
+  # Constructon
+  # @param bean_factory bean factory
+  def initialize(bean_factory)
+    @bean_factory = bean_factory
+  end
+
+  # Returns a bean 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
+  end
+
+  # Delete bean from scope
+  # @param bean_metadata [BeanMetadata] bean metadata
+  def delete_bean(bean_metadata)
+    RequestStore.store[:_callme_beans].delete(bean_metadata.name)
+  end
+end

data/lib/callme/scopes/singleton_scope.rb

@@ -0,0 +1,29 @@
+# Singleton scope returns the same bean instance
+# on each call
+class Callme::Scopes::SingletonScope
+
+  # Constructon
+  # @param bean_factory bean factory
+  def initialize(bean_factory)
+    @beans = {}
+    @bean_factory = bean_factory
+  end
+
+  # Returns the same bean 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
+  end
+
+  # Delete bean from scope
+  # @param bean_metadata [BeanMetadata] bean metadata
+  def delete_bean(bean_metadata)
+    @beans.delete(bean_metadata.name)
+  end
+end

data/lib/callme/scopes.rb

@@ -0,0 +1,2 @@
+module Callme::Scopes
+end

data/lib/callme/version.rb

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

data/lib/callme.rb

@@ -0,0 +1,4 @@
+require 'ext/vendored_activesupport'
+require 'callme/version'
+require 'callme/inject'
+require 'callme/container'

data/lib/ext/vendored_activesupport.rb

@@ -0,0 +1,181 @@
+##### vendored code from active_support (5.0.0) for Class.class_attribute  ####
+# require 'active_support/core_ext/class/attribute'
+# require 'active_support/core_ext/kernel/singleton_class'
+# require 'active_support/core_ext/module/remove_method'
+# require 'active_support/core_ext/array/extract_options'
+
+unless defined?(ActiveSupport)
+  class Module
+    def remove_possible_method(method)
+      if method_defined?(method) || private_method_defined?(method)
+        undef_method(method)
+      end
+    end
+
+    def redefine_method(method, &block)
+      remove_possible_method(method)
+      define_method(method, &block)
+    end
+  end
+
+  module Kernel
+    # class_eval on an object acts like singleton_class.class_eval.
+    def class_eval(*args, &block)
+      singleton_class.class_eval(*args, &block)
+    end
+  end
+
+  class Hash
+    # By default, only instances of Hash itself are extractable.
+    # Subclasses of Hash may implement this method and return
+    # true to declare themselves as extractable. If a Hash
+    # is extractable, Array#extract_options! pops it from
+    # the Array when it is the last element of the Array.
+    def extractable_options?
+      instance_of?(Hash)
+    end
+  end
+
+  class Array
+    # Extracts options from a set of arguments. Removes and returns the last
+    # element in the array if it's a hash, otherwise returns a blank hash.
+    #
+    #   def options(*args)
+    #     args.extract_options!
+    #   end
+    #
+    #   options(1, 2)        # => {}
+    #   options(1, 2, a: :b) # => {:a=>:b}
+    def extract_options!
+      if last.is_a?(Hash) && last.extractable_options?
+        pop
+      else
+        {}
+      end
+    end
+  end
+
+  class Class
+    # Declare a class-level attribute whose value is inheritable by subclasses.
+    # Subclasses can change their own value and it will not impact parent class.
+    #
+    #   class Base
+    #     class_attribute :setting
+    #   end
+    #
+    #   class Subclass < Base
+    #   end
+    #
+    #   Base.setting = true
+    #   Subclass.setting            # => true
+    #   Subclass.setting = false
+    #   Subclass.setting            # => false
+    #   Base.setting                # => true
+    #
+    # In the above case as long as Subclass does not assign a value to setting
+    # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
+    # would read value assigned to parent class. Once Subclass assigns a value then
+    # the value assigned by Subclass would be returned.
+    #
+    # This matches normal Ruby method inheritance: think of writing an attribute
+    # on a subclass as overriding the reader method. However, you need to be aware
+    # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
+    # In such cases, you don't want to do changes in places but use setters:
+    #
+    #   Base.setting = []
+    #   Base.setting                # => []
+    #   Subclass.setting            # => []
+    #
+    #   # Appending in child changes both parent and child because it is the same object:
+    #   Subclass.setting << :foo
+    #   Base.setting               # => [:foo]
+    #   Subclass.setting           # => [:foo]
+    #
+    #   # Use setters to not propagate changes:
+    #   Base.setting = []
+    #   Subclass.setting += [:foo]
+    #   Base.setting               # => []
+    #   Subclass.setting           # => [:foo]
+    #
+    # For convenience, an instance predicate method is defined as well.
+    # To skip it, pass <tt>instance_predicate: false</tt>.
+    #
+    #   Subclass.setting?       # => false
+    #
+    # Instances may overwrite the class value in the same way:
+    #
+    #   Base.setting = true
+    #   object = Base.new
+    #   object.setting          # => true
+    #   object.setting = false
+    #   object.setting          # => false
+    #   Base.setting            # => true
+    #
+    # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+    #
+    #   object.setting          # => NoMethodError
+    #   object.setting?         # => NoMethodError
+    #
+    # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+    #
+    #   object.setting = false  # => NoMethodError
+    #
+    # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
+    def class_attribute(*attrs)
+      options = attrs.extract_options!
+      instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+      instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+      instance_predicate = options.fetch(:instance_predicate, true)
+
+      attrs.each do |name|
+        define_singleton_method(name) { nil }
+        define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+
+        ivar = "@#{name}"
+
+        define_singleton_method("#{name}=") do |val|
+          singleton_class.class_eval do
+            remove_possible_method(name)
+            define_method(name) { val }
+          end
+
+          if singleton_class?
+            class_eval do
+              remove_possible_method(name)
+              define_method(name) do
+                if instance_variable_defined? ivar
+                  instance_variable_get ivar
+                else
+                  singleton_class.send name
+                end
+              end
+            end
+          end
+          val
+        end
+
+        if instance_reader
+          remove_possible_method name
+          define_method(name) do
+            if instance_variable_defined?(ivar)
+              instance_variable_get ivar
+            else
+              self.class.public_send name
+            end
+          end
+          define_method("#{name}?") { !!public_send(name) } if instance_predicate
+        end
+
+        attr_writer name if instance_writer
+      end
+    end
+
+    private
+
+      unless respond_to?(:singleton_class?)
+        def singleton_class?
+          ancestors.first != self
+        end
+      end
+  end
+end

data/spec/callme/container_spec.rb

@@ -0,0 +1,235 @@
+require 'spec_helper'
+require 'callme'
+
+describe Callme::Container do
+
+  class Logger
+    attr_accessor :appender
+  end
+  class Appender
+  end
+  class Printer
+  end
+
+  describe "bean definitions" do
+    let(:container) do
+      container = Callme::Container.new
+      container.bean(:appender, class: Appender)
+      container.bean(:logger, class: Logger) do
+        attr :appender, ref: :appender
+      end
+      container.bean(:printer, class: Printer, instance: false)
+      container
+    end
+    it "should instanciate bean and it's dependencies" do
+      container[:logger].should be_a(Logger)
+      container[:logger].appender.should be_a(Appender)
+      container[:printer].should be(Printer)
+    end
+
+    it "container should return the same instance on each call" do
+      logger = container[:logger]
+      container[:logger].should == logger
+    end
+  end
+
+  describe "eager_load_bean_classes" do
+    let(:container) do
+      container = Callme::Container.new
+      container.bean(:appender, class: 'Appender')
+      container.bean(:logger, class: 'Logger') do
+        attr :appender, ref: :appender
+      end
+      container.bean(:printer, class: 'Printer', instance: false)
+      container
+    end
+
+    it "should eager load bean classes" do
+      container.eager_load_bean_classes
+    end
+  end
+
+
+  describe "#replace_bean" do
+    it "should replace bean definition" do
+      container = Callme::Container.new
+      container.bean(:appender, class: Appender)
+      container[:appender].should be_a(Appender)
+
+      container.replace_bean(:appender, class: Logger)
+      container[:appender].should be_a(Logger)
+    end
+  end
+
+  describe "passing bean definitions to container constructor" do
+    let(:resource) do
+      Proc.new do |c|
+        c.bean(:appender, class: 'Appender')
+        c.bean(: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])
+      container[:logger].should be_a(Logger)
+      container[:appender].should be_a(Appender)
+    end
+
+  end
+
+  describe "inheritance" do
+    class Form
+      inject :validator
+    end
+
+    class Circle < Form
+      inject :circle_validator
+    end
+    class Rectangle < Form
+      inject :rectangle_validator
+    end
+
+    class Validator
+    end
+    class CircleValidator
+    end
+    class RectangleValidator
+    end
+
+    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)
+      end
+    end
+
+    it "dependencies in subclasses shouldn't affect on each other" do
+      container[:circle].circle_validator.should       be_a(CircleValidator)
+      container[:rectangle].rectangle_validator.should be_a(RectangleValidator)
+    end
+  end
+
+  describe "bean scopes" do
+    class ContactsService
+      inject :contacts_repository
+      inject :contacts_validator
+    end
+    class ContactsRepository
+    end
+    class ContactsValidator
+    end
+
+    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
+    end
+
+    it "should instanciate bean 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
+      RequestStore.clear! # new request
+      third_repo  = container[:contacts_service].contacts_repository
+      first_repo.should_not == third_repo
+    end
+
+    it "should instanciate bean 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
+    end
+  end
+
+  describe "factory method" do
+    module Test
+      class Config
+      end
+      class ConfigsFactory
+        def load_config
+          Config.new
+        end
+      end
+    end
+
+    let(:container) do
+      Callme::Container.new do |c|
+        c.bean :config, class: Test::ConfigsFactory, factory_method: :load_config
+      end
+    end
+
+    it "should instantiate bean using factory method" do
+      container[:config].should be_instance_of(Test::Config)
+    end
+  end
+
+  describe "parent container" do
+    class ContactBook
+      inject :contacts_repository
+      inject :validator, ref: :contact_validator
+    end
+    class ContactBookService
+      inject :contacts_repository
+      inject :validator, ref: :contact_validator
+    end
+    class ContactsRepository
+    end
+    class ContactValidator
+    end
+    class TestContactValidator
+    end
+
+    class AnotherTestContactValidator
+    end
+
+
+    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")
+      end
+    }
+
+    let(:container){
+      Callme::Container.with_parent(parent) do |c|
+        c.bean(:contact_validator,    class: TestContactValidator)
+      end
+    }
+
+    it "works for direct beans" do
+      expect(container[:contact_validator]).to be_a(TestContactValidator)
+      expect(container[:contact_book_service].validator).to be_a(TestContactValidator)
+    end
+
+    it "works for in-direct dependencies" do
+      expect(container[:contact_book_service].validator).to be_a(TestContactValidator)
+    end
+
+    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)
+      expect(parent[:contact_validator]).to be_a(AnotherTestContactValidator)
+      parent.reset!
+      expect(parent[:contact_book_service].validator).to be_a(AnotherTestContactValidator)
+      expect(container[:contact_book_service].validator).to be_a(TestContactValidator)
+    end
+
+    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)
+      parent.reset!
+      container.reset!
+      expect(parent[:contact_validator]).to be_a(ContactValidator)
+      expect(container[:contact_validator]).to be_a(AnotherTestContactValidator)
+    end
+  end
+end

data/spec/callme/inject_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+# Ensures that :inject keyword works as it should
+describe "Object.inject" do
+  class ContactBook
+    inject :contacts_repository
+    inject :validator, ref: :contact_validator
+  end
+  class ContactBookService
+    inject :contacts_repository
+    inject :validator, ref: :contact_validator
+  end
+  class ContactsRepository
+  end
+  class ContactValidator
+  end
+
+  let(:container) do
+    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")
+    end
+  end
+
+  it "should autowire dependencies" do
+    container[:contact_book].contacts_repository.should be_a(ContactsRepository)
+    container[:contact_book].validator.should be_a(ContactValidator)
+  end
+
+  it "should lazy autowire dependencies for string class names" do
+    container[:contact_book_service].contacts_repository.should be_a(ContactsRepository)
+    container[:contact_book_service].validator.should be_a(ContactValidator)
+  end
+
+  it "should raise ArgumentError if non-symbol passed as dependency name" do
+    expect do
+      class SomeClass
+        inject 'bar'
+      end
+    end.to raise_error(ArgumentError, "dependency name should be a symbol")
+  end
+
+  it "inject should define instance variable" do
+    container[:contact_book].instance_variable_get(:@contacts_repository).should be_a(ContactsRepository)
+  end
+
+  it "inject should not define class variable" do
+    expect do
+      container[:contact_book].class.contacts_repository
+    end.to raise_error(NoMethodError)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'callme'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+end