smart_ioc 0.1.13

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 651654180ff6efe44a53a5bf8295d0fdc2216efe
+  data.tar.gz: 7aff613bd666008bf5f444f7aeb1b8641a8c0e0e
+SHA512:
+  metadata.gz: 53900c9682dab42dc691fa95e504a3e5f2eb67daa312532cc7a239d33bf2673118b20c9ebc6a50a5151689e04f052bd6faaa1d6bdc9374462988ecf38d51179b
+  data.tar.gz: 1b8bc3b293360604e3b32cfe71b381f93d4e920352e482d7764faf3b50fdfdd6821134d7babe443568fada62bf7b7c6acc6f51f170f08afd385284e141b1eddc

data/.gitignore

@@ -0,0 +1,6 @@
+vendor/
+tags
+.bundle
+.DS_Store
+pkg
+.byebug_history

data/.travis.yml

@@ -0,0 +1,3 @@
+rvm:
+- 2.0.0
+script: "bundle exec rspec spec/"

data/.yardops

@@ -0,0 +1 @@
+lib/**/*.rb

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in aggregate_builder.gemspec
+gemspec
+
+group :test do
+  gem 'rspec'
+  gem 'byebug'
+end

data/Gemfile.lock

@@ -0,0 +1,32 @@
+PATH
+  remote: .
+  specs:
+    smart_ioc (0.1.13)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (9.0.6)
+    diff-lcs (1.2.5)
+    rake (10.1.1)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.4)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.3)
+  byebug
+  rake
+  rspec
+  smart_ioc!
+
+BUNDLED WITH
+   1.13.6

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2016 Ruslan Gatiyatov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,91 @@
+SmartIoC is a smart and really simple IoC container for Ruby applications.
+
+## Installation
+`gem install smart_ioc`
+
+## Setup
+   Set package name and source package folder with beans. SmartIoC will parse source files and detect bean definitions automatically for you.
+
+   ```ruby
+      SmartIoC.find_package_beans(:PACKAGE_NAME, File.dirname(__FILE__))
+   ```
+
+    If you have saveral packages in your application (like if you are using [rdm package manager](https://github.com/droidlabs/rdm)) you can run SmartIoC.find_package_beans several time pointing it to source folder and setting different package name.
+
+## Basic information
+1. Different packages can use beans with same name.
+2. For a specific package you can declare beans with same name if they have different context.
+    ```ruby
+    class UsersRepository
+      bean :users_repository
+    end
+
+    class Test::UsersRepository
+      bean :users_repository, context: :test
+    end
+    ```
+3. You can extend `:default` context with any other in the following way:
+
+   ```ruby
+   SmartIoC::Container.get_instance.set_extra_context_for_package(:YOUR_PACKAGE_NAME, :test)
+   ```
+This allows to create test implementations that for any package dependencies.
+4. In order to get bean use `SmartIoC::Container.get_bean(:BEAN_NAME, package: :PACKAGE_NAME, context: :default)`. `package` and `context` are optional arguments.
+5. If you have name with same bean in different packages you will need to set package directly. You can simply do that in the following way:
+    ```ruby
+    class UsersCreator
+      bean :users_creator
+
+      inject :users_repository, from: :repositories
+
+      def create
+        user = User.new
+        users_repository.put(user)
+      end
+
+    end
+    ```
+6. Change dependency name inside your bean:
+    ```ruby
+    class UsersCreator
+      bean :users_creator
+
+      inject :repo, ref: :users_repository, from: :repositories
+
+      def create
+        user = User.new
+        repo.put(user)
+      end
+    end
+    ```
+7.  Use factory method to instantiate the bean
+    ```ruby
+    class RepositoryFactory
+      bean :users_creator, factory_method: :get_bean
+
+      inject :config
+      inject :users_repository
+      inject :admins_repository
+
+      def get_bean
+        if config.admin_access?
+          admins_repository
+        else
+          users_repository
+        end
+      end
+
+      def create
+        user = User.new
+        repo.put(user)
+      end
+    end
+    ```
+8. Class level beans (object will not be instantiated and class will be used for that bean instead). Set `instance: false`:
+
+    ```ruby
+    class UsersCreator
+      bean :users_creator, instance: false
+      inject :users_repository
+    end
+    ```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/smart_ioc/bean_definition.rb

@@ -0,0 +1,77 @@
+class SmartIoC::BeanDefinition
+  attr_reader :name, :package, :path, :klass, :scope, :instance, :factory_method,
+              :context, :dependencies
+
+  def initialize(name:, package:, path:, klass:, scope:, context:, instance:, factory_method:)
+    not_nil(name, :name)
+    not_nil(package, :package)
+    not_nil(path, :path)
+    not_nil(klass, :klass)
+    not_nil(scope, :scope)
+    not_nil(context, :context)
+    not_nil(instance, :instance)
+
+    @name           = name
+    @package        = package
+    @path           = path
+    @klass          = klass
+    @scope          = scope
+    @instance       = instance
+    @factory_method = factory_method
+    @context        = context
+
+    @dependencies = []
+  end
+
+  def add_dependency(bean_name:, ref: nil, package: nil)
+    if !bean_name.is_a?(Symbol)
+      raise ArgumentError, 'bean name should be a Symbol'
+    end
+
+    if ref && !ref.is_a?(Symbol)
+      raise ArgumentError, 'ref name should be a Symbol'
+    end
+
+    if package && !package.is_a?(Symbol)
+      raise ArgumentError, 'package/from should be a Symbol'
+    end
+
+    @dependencies << SmartIoC::BeanDependency.new(
+      bean:    bean_name,
+      ref:     ref,
+      package: package
+    )
+  end
+
+  def is_instance?
+    @instance
+  end
+
+  def has_factory_method?
+    !@factory_method.nil?
+  end
+
+  def ==(bean_definition)
+    bean_definition.klass == @klass
+  end
+
+  def inspect
+    str = []
+    str << "class:          #{@klass}"
+    str << "name:           :#{@name}"
+    str << "package:        :#{@package}"
+    str << "context:        :#{@context}"
+    str << "path:           #{@path}"
+    str << "instance:       #{@instance}"
+    str << "factory_method: #{@factory_method}"
+    str.join("\n")
+  end
+
+  private
+
+  def not_nil(value, name)
+    if value.nil?
+      raise ArgumentError, ":#{name} should not be blank"
+    end
+  end
+end

data/lib/smart_ioc/bean_definitions_storage.rb

@@ -0,0 +1,79 @@
+class SmartIoC::BeanDefinitionsStorage
+  def initialize
+    @collection = []
+  end
+
+  # @param bean_definition [BeanDefinition]
+  def push(bean_definition)
+    existing_bd = @collection.detect do |bd|
+      bd == bean_definition
+    end
+
+    if existing_bd
+      error_msg =
+%Q(Not able to add bean to definitions storage.
+Bean definition already exists.
+New bean details:
+  #{bean_definition.inspect}
+Existing bean details:
+  #{existing_bd.inspect})
+
+      raise ArgumentError, error_msg
+    end
+
+    @collection.push(bean_definition)
+  end
+
+  # @param klass [Class] bean class
+  # @return bean definition [BeanDefinition] or nil
+  def find_by_class(klass)
+    @collection.detect {|bd| bd.klass == klass}
+  end
+
+  def filter_by(bean_name, package = nil, context = nil)
+    bean_definitions = @collection.select do |bd|
+      bd.name == bean_name
+    end
+
+    if package
+      bean_definitions = bean_definitions.select do |bd|
+        bd.package == package
+      end
+    end
+
+    if context
+      bean_definitions = bean_definitions.select do |bd|
+        bd.context == context
+      end
+    end
+
+    bean_definitions
+  end
+
+  # @bean_name [Symbol] bean name
+  # @package [Symbol] package name
+  # @context [Array[Symbol]] context
+  def filter_by_with_drop_to_default_context(bean_name, package = nil, context = nil)
+    bean_definitions = @collection.select do |bd|
+      bd.name == bean_name
+    end
+
+    if package
+      bean_definitions = bean_definitions.select do |bd|
+        bd.package == package
+      end
+    end
+
+    if context
+      context_bean_definitions = bean_definitions.select do |bd|
+        bd.context == context
+      end
+
+      if !context_bean_definitions.empty?
+        bean_definitions = context_bean_definitions
+      end
+    end
+
+    bean_definitions
+  end
+end

data/lib/smart_ioc/bean_dependency.rb

@@ -0,0 +1,18 @@
+class SmartIoC::BeanDependency
+  attr_reader :bean, :ref, :package
+  attr_accessor :bean_definition
+
+  def initialize(bean:, ref:, package:)
+    @bean = bean
+    @ref = ref
+    @package = package
+  end
+
+  def ref
+    @ref || @bean
+  end
+
+  def ==(dependency)
+    dependency.bean == @bean && dependency.package == @package
+  end
+end

data/lib/smart_ioc/bean_factory.rb

@@ -0,0 +1,230 @@
+# Instantiates beans according to their scopes
+class SmartIoC::BeanFactory
+  def initialize(bean_definitions_storage, extra_package_contexts)
+    @bean_definitions_storage = bean_definitions_storage
+    @extra_package_contexts   = extra_package_contexts
+    @bean_file_loader         = SmartIoC::BeanFileLoader.new
+    @singleton_scope          = SmartIoC::Scopes::Singleton.new
+    @prototype_scope          = SmartIoC::Scopes::Prototype.new
+    @thread_scope             = SmartIoC::Scopes::Request.new
+  end
+
+  def clear_scopes
+    all_scopes.each(&:clear)
+  end
+
+  def force_clear_scopes
+    all_scopes.each(&:force_clear)
+  end
+
+  # Get bean from the container by it's name, package, context
+  # @param bean_name [Symbol] bean name
+  # @param package [Symbol] package name
+  # @param context [Symbol] context
+  # @return bean instance
+  # @raise [ArgumentError] if bean is not found
+  # @raise [ArgumentError] if ambiguous bean definition was found
+  def get_bean(bean_name, package: nil, context: SmartIoC::Container::DEFAULT_CONTEXT)
+    if !context.is_a?(Symbol)
+      raise ArgumentError, 'context should be a Symbol'
+    end
+
+    @bean_file_loader.require_bean(bean_name)
+
+    bds = @bean_definitions_storage.filter_by(bean_name, package, context)
+    if bds.size > 1
+      raise ArgumentError, "Unable to create bean :#{bean_name}.\nSeveral definitions were found.\n#{bds.map(&:inspect).join("\n\n")}"
+    elsif bds.size == 0
+      raise ArgumentError, "Unable to find bean :#{bean_name} in any packages"
+    end
+
+    bean_definition = bds.first
+    dependency_cache = {}
+    beans_cache = {}
+
+    autodetect_bean_definitions_for_dependencies(bean_definition, dependency_cache)
+    preload_beans(bean_definition, dependency_cache, beans_cache)
+    load_bean(bean_definition, dependency_cache, beans_cache)
+  end
+
+  private
+
+  def autodetect_bean_definitions_for_dependencies(bean_definition, dependency_cache)
+    bean_definition.dependencies.each do |dependency|
+      next if dependency_cache.has_key?(dependency)
+
+      @bean_file_loader.require_bean(dependency.ref)
+
+      bd = autodetect_bean_definition(
+        dependency.ref, dependency.package, bean_definition.package
+      )
+
+      dependency_cache[dependency] = bd
+
+      autodetect_bean_definitions_for_dependencies(bd, dependency_cache)
+    end
+  end
+
+  def autodetect_bean_definition(bean, package, parent_bean_package)
+    if package
+      bean_context = @extra_package_contexts.get_context(package)
+      bds = @bean_definitions_storage.filter_by_with_drop_to_default_context(bean, package, bean_context)
+
+      return bds.first if bds.size == 1
+      raise ArgumentError, "bean :#{bean} is not found in package :#{package}"
+    end
+
+    if parent_bean_package
+      bean_context = @extra_package_contexts.get_context(parent_bean_package)
+      bds = @bean_definitions_storage.filter_by_with_drop_to_default_context(bean, parent_bean_package, bean_context)
+
+      return bds.first if bds.size == 1
+    end
+
+    bds = @bean_definitions_storage.filter_by(bean)
+    bds_by_package = bds.group_by(&:package)
+    smart_bds = []
+
+    bds_by_package.each do |package, bd_list|
+      # try to find bean definition with package context
+      bd = bd_list.detect {|bd| bd.context == @extra_package_contexts.get_context(bd.package)}
+      smart_bds << bd if bd
+
+      # last try: find for :default context
+      if !bd
+        bd = bd_list.detect {|bd| bd.context == SmartIoC::Container::DEFAULT_CONTEXT}
+        smart_bds << bd if bd
+      end
+    end
+
+    if smart_bds.size > 1
+      raise ArgumentError, "Unable to autodetect bean :#{bean}.\nSeveral definitions were found.\n#{smart_bds.map(&:inspect).join("\n\n")}. Set package directly for injected dependency"
+    end
+
+    return smart_bds.first
+  end
+
+  def preload_beans(bean_definition, dependency_cache, beans_cache)
+    preload_bean_instance(bean_definition, beans_cache)
+
+    bean_definition.dependencies.each do |dependency|
+      bd = dependency_cache[dependency]
+
+      next if beans_cache.has_key?(bd)
+      preload_beans(bd, dependency_cache, beans_cache)
+    end
+  end
+
+  def preload_bean_instance(bean_definition, beans_cache)
+    return beans_cache[bean_definition] if beans_cache.has_key?(bean_definition)
+
+    scope = get_scope(bean_definition)
+    bean = scope.get_bean(bean_definition.klass)
+
+    if bean
+      beans_cache[bean_definition] = bean
+      return bean
+    end
+
+    bean = if bean_definition.is_instance?
+      bean_definition.klass.allocate
+    else
+      bean_definition.klass
+    end
+
+    scope.save_bean(bean_definition.klass, bean)
+    beans_cache[bean_definition] = bean
+
+    bean
+  end
+
+  def load_bean(bean_definition, dependency_cache, beans_cache)
+    # first let's setup beans with factory_methods
+    zero_dep_bd_with_factory_methods = []
+    bd_with_factory_methods = []
+
+    beans_cache.each do |bean_definition, bean|
+      if bean_definition.has_factory_method?
+        if bean_definition.dependencies.size == 0
+          zero_dep_bd_with_factory_methods << bean_definition
+        else
+          bd_with_factory_methods << bean_definition
+        end
+      end
+    end
+
+    bd_with_factory_methods.each do |bean_definition|
+      if cross_refference_bd = get_cross_refference(bd_with_factory_methods, bean_definition, dependency_cache)
+        raise ArgumentError, "Factory method beans should not cross refference each other. Bean :#{bean_definition.name} cross refferences bean :#{cross_refference_bd.name}."
+      end
+    end
+
+    (zero_dep_bd_with_factory_methods + bd_with_factory_methods).each do |bean_definition|
+      inject_beans(bean_definition, dependency_cache, beans_cache)
+      bean = beans_cache[bean_definition]
+      bean = bean.send(bean_definition.factory_method)
+      beans_cache[bean_definition] = bean
+    end
+
+    inject_beans(bean_definition, dependency_cache, beans_cache)
+
+    beans_cache[bean_definition]
+  end
+
+  def inject_beans(bean_definition, dependency_cache, beans_cache)
+    bean = beans_cache[bean_definition]
+    bean_definition.dependencies.each do |dependency|
+      bd = dependency_cache[dependency]
+      dep_bean = beans_cache[bd]
+      bean.instance_variable_set(:"@#{dependency.bean}", dep_bean)
+      inject_beans(bd, dependency_cache, beans_cache)
+    end
+  end
+
+  def get_cross_refference(refer_bean_definitions, current_bean_definition, dependency_cache, seen_bean_definitions = [])
+    current_bean_definition.dependencies.each do |dependency|
+      bd = dependency_cache[dependency]
+
+      next if seen_bean_definitions.include?(bd)
+
+      if refer_bean_definitions.include?(bd)
+        return bd
+      end
+
+      if crbd = get_cross_refference(refer_bean_definitions, bd, dependency_cache, seen_bean_definitions + [bd])
+        return crbd
+      end
+    end
+
+    nil
+  end
+
+  def set_bean_dependencies(bean, bean_definition, parent_bean_package)
+    bean_definition.dependencies.each do |dependency|
+      context = if dependency.package
+        @extra_package_contexts.get_context(dependency.package)
+      end
+
+      dependent_bean = get_or_load_bean(dependency.ref, dependency.package, context, bean_definition.package)
+
+      bean.instance_variable_set(:"@#{dependency.bean}", dependent_bean)
+    end
+  end
+
+  def all_scopes
+    [@singleton_scope, @prototype_scope, @thread_scope]
+  end
+
+  def get_scope(bean_definition)
+    case bean_definition.scope
+    when SmartIoC::Scopes::Singleton::VALUE
+      @singleton_scope
+    when SmartIoC::Scopes::Prototype::VALUE
+      @prototype_scope
+    when SmartIoC::Scopes::Request::VALUE
+      @thread_scope
+    else
+      raise ArgumentError, "bean definition for :#{bean_definition.name} has unsupported scope :#{bean_definition.scope}"
+    end
+  end
+end

data/lib/smart_ioc/bean_file_loader.rb

@@ -0,0 +1,26 @@
+class SmartIoC::BeanFileLoader
+  def initialize
+    @loaded_locations = {}
+  end
+
+  # @param bean_name [Symbol] bean name
+  # return nil
+  def require_bean(bean_name)
+    locations = SmartIoC::BeanLocations.get_bean_locations(bean_name)
+
+    # load *.rb file if extra bean location was added or it was not loaded yet
+    location_count = locations.values.flatten.size
+
+    if !@loaded_locations.has_key?(bean_name) || @loaded_locations[bean_name] != location_count
+      locations.each do |package_name, locations|
+        locations.each do |location|
+          require location
+        end
+      end
+
+      @loaded_locations[bean_name] = location_count
+    end
+
+    nil
+  end
+end

data/lib/smart_ioc/bean_locations.rb

@@ -0,0 +1,71 @@
+# SmartIoC::BeanLocations is a storage for locations of package bean definitions.
+# Storage structure:
+# {
+#   PACKAGE_NAME => { BEAN_SYM => BEAN_PATH}
+# }
+# Ex:
+# {
+#   repository: {
+#     users_repository: ['/app/core/infrastructure/repository/users.rb'],
+#     posts_repository: ['/app/core/infrastructure/repository/posts.rb']
+#   }
+# }
+class SmartIoC::BeanLocations
+  @data = {}
+
+  class << self
+    # @param package_name [Symbol] bean package name (ex: :repository)
+    # @param bean [Symbol] bean name (ex: :users_repository)
+    # @param bean_path [String] bean name (ex: :users_repository)
+    # @return nil
+    # @raise [ArgumentError] if bean previous bean definition with same name was found for package
+    def add_bean(package_name, bean, bean_path)
+      @data[package_name] ||= {}
+      package_beans = @data[package_name]
+
+      package_beans[bean] ||= []
+      package_beans[bean].push(bean_path)
+
+      nil
+    end
+
+    # @param bean [Symbol] bean name (ex: :users_repository)
+    # @return Hash[Array[String]] hash of bean definitions from all packages
+    def get_bean_locations(bean)
+      locations = {}
+
+      @data.each do |package, bean_locations|
+        if bean_locations.has_key?(bean)
+          locations[package] ||= []
+          locations[package] += bean_locations[bean]
+        end
+      end
+
+      locations
+    end
+
+    def load_all
+      @data.each do |package, bean_locations|
+        bean_locations.each do |bean, path|
+          load(path)
+        end
+      end
+    end
+
+    def clear
+      @data = {}
+    end
+
+    # @param path [String] absolute bean path
+    # @return [nil or String] package name be absolute bean path
+    def get_bean_package(path)
+      @data.each do |package, bean_locations|
+        if bean_locations.values.flatten.include?(path)
+          return package
+        end
+      end
+
+      nil
+    end
+  end
+end