smart_ioc 0.1.13

data/lib/smart_ioc/bean_locator.rb

@@ -0,0 +1,32 @@
+class SmartIoC::BeanLocator
+  BEAN_PATTERN = /bean\s+(:[a-zA-z0-9\-\_]+)/
+
+  # @param package_name [Symbol] package name for bean (ex: :repository)
+  # @param dir [String] absolute path for directory with bean definitions
+  # @return nil
+  def locate_beans(package_name, dir)
+    if !package_name.is_a?(Symbol)
+      raise ArgumentError, 'package name should be a symbol'
+    end
+
+    package_name = package_name
+
+    Dir.glob(File.join(dir, '**/*.rb')).each do |file_path|
+      source_str = File.read(file_path)
+
+      beans = find_package_beans(source_str)
+
+      beans.each do |bean_name|
+        SmartIoC::BeanLocations.add_bean(package_name, bean_name, file_path)
+      end
+    end
+    nil
+  end
+
+  private
+
+  def find_package_beans(source_str)
+    tokens = source_str.scan(BEAN_PATTERN)
+    tokens.flatten.uniq.map {|token| token.gsub(':', '').to_sym}
+  end
+end

data/lib/smart_ioc/container.rb

@@ -0,0 +1,143 @@
+module SmartIoC
+  # SmartIoC::Container is a beans store used for dependency injection
+  class Container
+    DEFAULT_CONTEXT = :default
+
+    class << self
+      def get_instance
+        @container ||= SmartIoC::Container.allocate
+      end
+
+      def clear
+        @container = nil
+      end
+
+      def get_bean(bean_name, package: nil, context: SmartIoC::Container::DEFAULT_CONTEXT)
+        get_instance.get_bean(bean_name, package: package, context: context)
+      end
+    end
+
+    def initialize
+      raise ArgumentError, "SmartIoC::Container should not be allocated. Use SmartIoC::Container.get_instance instead"
+    end
+
+    # @param bean_name [Symbol] bean name
+    # @param klass [Class] bean class name
+    # @param path [String] bean file absolute path
+    # @param scope [Symbol] scope value
+    # @param context [Symbol] bean context
+    # @return [SmartIoC::BeanDefinition] bean definition
+    def register_bean(bean_name:, klass:, context:, scope:, path:,
+                      factory_method: nil, package_name: nil, instance: true)
+      if !bean_name.is_a?(Symbol)
+        raise ArgumentError, 'bean name should be a Symbol'
+      end
+
+      if !klass.is_a?(Class)
+        raise ArgumentError, 'bean class should be a Class'
+      end
+
+      if !path.is_a?(String)
+        raise ArgumentError, 'path should be a String'
+      end
+
+      if !(instance.is_a?(TrueClass) || instance.is_a?(FalseClass))
+        raise ArgumentError, 'instance should be true or false'
+      end
+
+      if (factory_method && !factory_method.is_a?(Symbol))
+        raise ArgumentError, 'factory method should be a Symbol'
+      end
+
+      context ||= DEFAULT_CONTEXT
+
+      if !context.is_a?(Symbol)
+        raise ArgumentError, 'context should be a Symbol'
+      end
+
+      scope ||= SmartIoC::Scopes::Singleton::VALUE
+
+      allowed_scopes = [
+        SmartIoC::Scopes::Prototype::VALUE,
+        SmartIoC::Scopes::Singleton::VALUE,
+        SmartIoC::Scopes::Request::VALUE
+      ]
+
+      if !allowed_scopes.include?(scope)
+        raise ArgumentError, "bean scope should be one of #{allowed_scopes.inspect}"
+      end
+
+      package_name ||= SmartIoC::BeanLocations.get_bean_package(path)
+
+      if !package_name
+        raise ArgumentError, %Q(
+          Package name should be given for bean :#{bean_name}.
+          You should specify package name directly or run
+
+          SmartIoC.find_package_beans(package_name, dir)
+
+          to setup beans before you actually register them.
+        )
+      end
+
+      bean_definition = SmartIoC::BeanDefinition.new(
+        name:           bean_name,
+        package:        package_name,
+        path:           path,
+        klass:          klass,
+        instance:       instance,
+        factory_method: factory_method,
+        context:        context,
+        scope:          scope
+      )
+
+      bean_definitions_storage.push(bean_definition)
+
+      bean_definition
+    end
+
+    # Returns bean definition for specific class
+    # @param klass [Class] class name
+    # return [BeanDefinition]
+    def get_bean_definition_by_class(klass)
+      bean_definitions_storage.find_by_class(klass)
+    end
+
+    # Sets extra context for specific package
+    # @param package_name [Symbol] package name
+    # @param context [Symbol] context (ex: :test)
+    def set_extra_context_for_package(package_name, context)
+      extra_package_contexts.set_context(package_name, context)
+    end
+
+    # @param bean_name [Symbol] bean name
+    # @param optional package [Symbol] package name
+    # @param optional context [Symbol] package context
+    # @return bean instance from container
+    def get_bean(bean_name, package: nil, context: SmartIoC::Container::DEFAULT_CONTEXT)
+      bean_factory.get_bean(bean_name, package: package, context: context)
+    end
+
+    def clear_scopes
+      bean_factory.clear_scopes
+    end
+
+    def force_clear_scopes
+      bean_factory.force_clear_scopes
+    end
+
+    private
+
+    def bean_factory
+      @bean_factory ||= SmartIoC::BeanFactory.new(bean_definitions_storage, extra_package_contexts)
+    end
+
+    def extra_package_contexts
+      @extra_package_contexts ||= SmartIoC::ExtraPackageContexts.new
+    end
+
+    def bean_definitions_storage
+      @bean_definitions_storage ||= SmartIoC::BeanDefinitionsStorage.new
+    end
+  end
+end

data/lib/smart_ioc/extra_package_contexts.rb

@@ -0,0 +1,29 @@
+class SmartIoC::ExtraPackageContexts
+  def initialize
+    @data = {}
+  end
+
+  # @param package_name [Symbol]
+  # @param context [Symbol]
+  def set_context(package_name, context)
+    if !package_name.is_a?(Symbol)
+      raise ArgumentError, "package name should be a Symbol"
+    end
+
+    if !context.is_a?(Symbol)
+      raise ArgumentError, "context should be a Symbol"
+    end
+
+    @data[package_name] = context
+  end
+
+  def get_context(package_name)
+    @data[package_name] || SmartIoC::Container::DEFAULT_CONTEXT
+  end
+
+  # @param package_name [Symbol]
+  def clear_context(package_name)
+    @data.delete(package_name)
+    nil
+  end
+end

data/lib/smart_ioc/inject_metadata.rb

@@ -0,0 +1,13 @@
+class SmartIoC::InjectMetadata
+  attr_reader :bean, :ref, :from
+
+  def initialize(bean, ref, from)
+    @bean = bean
+    @ref = ref
+    @from = from
+  end
+
+  def ref
+    @ref || @bean
+  end
+end

data/lib/smart_ioc/iocify.rb

@@ -0,0 +1,101 @@
+# Extend Object with bean declaration and bean injection functionality
+# Example of usage:
+# class Bar
+#   bean :bar
+# end
+#
+# class Foo
+#   include SmartIoC::Iocify
+#   bean :foo, scope: :prototype, instance: false, factory_method: :get_beans
+#
+#   inject :bar
+#   inject :some_bar, ref: bar, from: :repository
+#
+#   def hello_world
+#     puts 'Hello world'
+#   end
+# end
+#
+# SmartIoC::Container.get_bean(:bar).hello_world
+module SmartIoC::Iocify
+  def self.included base
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    # @param bean_name [Symbol] bean name
+    # @param scope [Symbol] bean scope (defaults to :singleton)
+    # @param package [nil or Symbol]
+    # @param factory_method [nil or Symbol] factory method to get bean
+    # @param instance [Boolean] instance based bean or class-based
+    # @param context [Symbol] set bean context (ex: :test)
+    # @return nil
+    def bean(bean_name, scope: nil, package: nil, instance: true, factory_method: nil, context: nil)
+      file_path = caller[0].split(':').first
+
+      bean_definition = SmartIoC::Container.get_instance.get_bean_definition_by_class(self)
+
+      # skip if bean was registered
+      return if bean_definition
+
+      bean_definition = SmartIoC::Container.get_instance.register_bean(
+        bean_name:      bean_name,
+        klass:          self,
+        scope:          scope,
+        path:           file_path,
+        package_name:   package,
+        instance:       instance,
+        factory_method: factory_method,
+        context:        context
+      )
+
+      if bean_definition.is_instance?
+        class_eval %Q(
+          def initialize
+            raise ArgumentError, "constructor based allocation is not allowed for beans. Use ioc container to allocate bean."
+          end
+        )
+      end
+
+      nil
+    end
+
+    # @param bean_name [Symbol] injected bean name
+    # @param ref [Symbol] refferece bean to be sef as bean_name
+    # @param from [Symbol] package name
+    # @return nil
+    # @raise [ArgumentError] if bean_name is not a Symbol
+    # @raise [ArgumentError] if ref provided and ref is not a Symbol
+    # @raise [ArgumentError] if from provided and from is not a Symbol
+    # @raise [ArgumentError] if bean with same name was injected before
+    def inject(bean_name, ref: nil, from: nil)
+      bean_definition = SmartIoC::Container.get_instance.get_bean_definition_by_class(self)
+
+      if bean_definition.nil?
+        raise ArgumentError, "current class is not registered as bean. Add bean :bean_name declaration"
+      end
+
+      bean_definition.add_dependency(
+        bean_name: bean_name,
+        ref:       ref,
+        package:   from
+      )
+
+      if bean_definition.is_instance?
+        class_eval %Q(
+          private
+            attr_reader :#{bean_name}
+        )
+      else
+        class_eval %Q(
+          class << self
+            private
+              attr_reader :#{bean_name}
+          end
+        )
+      end
+
+      nil
+    end
+  end
+end

data/lib/smart_ioc/scopes/prototype.rb

@@ -0,0 +1,26 @@
+# Prototype scope instantiates new bean instance on each call
+class SmartIoC::Scopes::Prototype
+  VALUE = :prototype
+
+  # Get new bean instance
+  # @param bean_definition [BeanDefinition] bean definition
+  # @returns nil
+  def get_bean(bean_definition)
+    # do nothing
+  end
+
+  # @param klass [Class] bean class
+  # @param bean [Any Object] bean object
+  # @returns nil
+  def save_bean(klass, bean)
+    # do nothing
+  end
+
+  def clear
+    # do nothing
+  end
+
+  def force_clear
+    # do nothing
+  end
+end

data/lib/smart_ioc/scopes/request.rb

@@ -0,0 +1,35 @@
+# Request scope instantiates new bean instance if it's not present in Thread.current
+class SmartIoC::Scopes::Request < SmartIoC::Scopes::Singleton
+  VALUE = :request
+  KEY   = :__SmartIoC
+
+  # @param bean_factory bean factory
+  def initialize
+    clear
+  end
+
+
+  # @param klass [Class] bean class
+  # @returns bean instance or nil if not stored
+  def get_bean(klass)
+    @beans[klass]
+  end
+
+  # @param klass [Class] bean class
+  # @param bean [Any Object] bean object
+  # @returns nil
+  def save_bean(klass, bean)
+    @beans[klass] = bean
+    nil
+  end
+
+  def clear
+    Thread.current[KEY] = {}
+    @beans = Thread.current[KEY]
+    nil
+  end
+
+  def force_clear
+    clear
+  end
+end

data/lib/smart_ioc/scopes/singleton.rb

@@ -0,0 +1,31 @@
+# Singleton scope returns same bean instance on each call
+class SmartIoC::Scopes::Singleton
+  VALUE = :singleton
+
+  def initialize
+    @beans = {}
+  end
+
+  # @param klass [Class] bean class
+  # @returns bean instance or nil if not stored
+  def get_bean(klass)
+    @beans[klass]
+  end
+
+  # @param klass [Class] bean class
+  # @param bean [Any Object] bean object
+  # @returns nil
+  def save_bean(klass, bean)
+    @beans[klass] = bean
+    nil
+  end
+
+  def clear
+    # do nothing as singleton beans are being instantiated only once
+  end
+
+  def force_clear
+    @beans = {}
+    nil
+  end
+end

data/lib/smart_ioc/scopes.rb

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

data/lib/smart_ioc/version.rb

@@ -0,0 +1,3 @@
+module SmartIoC
+  VERSION = "0.1.13"
+end

data/lib/smart_ioc.rb

@@ -0,0 +1,44 @@
+require 'smart_ioc/version'
+
+module SmartIoC
+  autoload :BeanDefinition,         'smart_ioc/bean_definition'
+  autoload :BeanDefinitionsStorage, 'smart_ioc/bean_definitions_storage'
+  autoload :BeanDependency,         'smart_ioc/bean_dependency'
+  autoload :BeanFactory,            'smart_ioc/bean_factory'
+  autoload :BeanFileLoader,         'smart_ioc/bean_file_loader'
+  autoload :BeanLocations,          'smart_ioc/bean_locations'
+  autoload :BeanLocator,            'smart_ioc/bean_locator'
+  autoload :Container,              'smart_ioc/container'
+  autoload :ExtraPackageContexts,   'smart_ioc/extra_package_contexts'
+  autoload :InjectMetadata,         'smart_ioc/inject_metadata'
+  autoload :Iocify,                 'smart_ioc/iocify'
+  autoload :Scopes,                 'smart_ioc/scopes'
+
+  module Scopes
+    autoload :Prototype, 'smart_ioc/scopes/prototype'
+    autoload :Singleton, 'smart_ioc/scopes/singleton'
+    autoload :Request,   'smart_ioc/scopes/request'
+  end
+
+  class << self
+    # @param package_name [String or Symbol] package name for bean definitions
+    # @param dir [String] absolute path with bean definitions
+    # @return nil
+    def find_package_beans(package_name, dir)
+      bean_locator = SmartIoC::BeanLocator.new
+      bean_locator.locate_beans(package_name.to_sym, dir)
+      nil
+    end
+
+    # Load all beans (usually required for production env)
+    def load_all_beans
+      SmartIoC::BeanLocations.load_all
+    end
+
+    # Full clear of data (mostly for tests)
+    def clear
+      SmartIoC::BeanLocations.clear
+      SmartIoC::Container.clear
+    end
+  end
+end

data/smart_ioc.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'smart_ioc/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "smart_ioc"
+  spec.version       = SmartIoC::VERSION
+  spec.authors       = ["Ruslan Gatiyatov"]
+  spec.email         = ["ruslan@droidlabs.pro"]
+  spec.description   = %q{Inversion of Control Container}
+  spec.summary       = %q{Inversion of Control Container}
+  spec.homepage      = "http://github.com/droidlabs/smart_ioc"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(spec)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+end

data/spec/smart_ioc/bean_definition_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe SmartIoC::BeanDefinition do
+  describe "::inspect" do
+    it {
+      bd = SmartIoC::BeanDefinition.new(
+        name: :test_bean,
+        package: :test_package,
+        path: 'current_dir',
+        klass: Object,
+        scope: :singleton,
+        context: :default,
+        instance: false,
+        factory_method: nil
+      )
+
+      str =
+"class:          Object
+name:           :test_bean
+package:        :test_package
+context:        :default
+path:           current_dir
+instance:       false
+factory_method: "
+
+      expect(bd.inspect).to eq(str)
+    }
+  end
+end

data/spec/smart_ioc/bean_locator_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe SmartIoC::BeanLocator do
+  before :all do
+    SmartIoC.clear
+
+    locator = SmartIoC::BeanLocator.new
+    current_dir = File.expand_path(File.dirname(__FILE__))
+    locator.locate_beans(:test, File.join(current_dir, 'example'))
+  end
+
+  it {
+    locations = SmartIoC::BeanLocations.get_bean_locations(:repository)
+
+    expect(locations[:test].size).to eq(3)
+    expect(locations[:test][0]).to match(/example\/admins\/repository\/admins_repository.rb/)
+    expect(locations[:test][1]).to match(/example\/admins\/repository\/test\/admins_repository.rb/)
+    expect(locations[:test][2]).to match(/example\/users\/repository\/users_repository.rb/)
+  }
+
+  it {
+    locations = SmartIoC::BeanLocations.get_bean_locations(:users_creator)
+
+    expect(locations[:test].size).to eq(1)
+    expect(locations[:test].first).to match(/example\/users\/services\/users_creator.rb/)
+  }
+end

data/spec/smart_ioc/example/admins/repository/admins_dao.rb

@@ -0,0 +1,20 @@
+class AdminsDAO
+  include SmartIoC::Iocify
+
+  bean :dao, instance: false
+
+  inject :config
+
+  @data = {}
+
+  class << self
+    def insert(entity)
+      config.app_name
+      @data[entity.id] = entity
+    end
+
+    def get(id)
+      @data[id]
+    end
+  end
+end

data/spec/smart_ioc/example/admins/repository/admins_repository.rb

@@ -0,0 +1,15 @@
+class AdminsRepository
+  include SmartIoC::Iocify
+
+  bean :repository
+
+  inject :dao
+
+  def put(user)
+    dao.insert(user)
+  end
+
+  def get(id)
+    dao.get(id)
+  end
+end

data/spec/smart_ioc/example/admins/repository/test/admins_repository.rb

@@ -0,0 +1,17 @@
+class TestAdminsRepository
+  include SmartIoC::Iocify
+
+  bean :repository, context: :test, instance: false
+
+  @data = {}
+
+  class << self
+    def put(user)
+      @data[user.id] = user
+    end
+
+    def get(id)
+      @data[id]
+    end
+  end
+end

data/spec/smart_ioc/example/users/repository/users_dao.rb

@@ -0,0 +1,17 @@
+class UsersDAO
+  include SmartIoC::Iocify
+
+  bean :dao, instance: false
+
+  @data = {}
+
+  class << self
+    def insert(entity)
+      @data[entity.id] = entity
+    end
+
+    def get(id)
+      @data[id]
+    end
+  end
+end

data/spec/smart_ioc/example/users/repository/users_repository.rb

@@ -0,0 +1,16 @@
+class UsersRepository
+  include SmartIoC::Iocify
+
+  bean :repository
+
+  inject :users_creator # just for testing purposes (circular load check)
+  inject :dao
+
+  def put(user)
+    dao.insert(user)
+  end
+
+  def get(id)
+    dao.get(id)
+  end
+end

data/spec/smart_ioc/example/users/services/users_creator.rb

@@ -0,0 +1,15 @@
+require_relative '../user'
+
+class UsersCreator
+  include SmartIoC::Iocify
+
+  bean :users_creator
+
+  inject :repository, from: :admins
+  inject :logger
+
+  def create(id, email)
+    user = User.new(id, email)
+    repository.put(user)
+  end
+end

data/spec/smart_ioc/example/users/user.rb

@@ -0,0 +1,8 @@
+class User
+  attr_reader :id, :email
+
+  def initialize(id, email)
+    @id = id
+    @email = email
+  end
+end

data/spec/smart_ioc/example/utils/config.rb

@@ -0,0 +1,15 @@
+class Config
+  include SmartIoC::Iocify
+
+  bean :config, factory_method: :get_config
+
+  class TestConfig
+    def app_name
+      'SmartIoC'
+    end
+  end
+
+  def get_config
+    TestConfig.new
+  end
+end