smart_container 0.4.0 → 0.8.1

data/Rakefile

@@ -4,6 +4,7 @@ require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'rubocop'
 require 'rubocop/rake_task'
+require 'rubocop-rails'
 require 'rubocop-performance'
 require 'rubocop-rspec'
 require 'rubocop-rake'
@@ -11,8 +12,8 @@ require 'rubocop-rake'
 RuboCop::RakeTask.new(:rubocop) do |t|
   config_path = File.expand_path(File.join('.rubocop.yml'), __dir__)
   t.options = ['--config', config_path]
-  t.requires << 'rubocop-performance'
   t.requires << 'rubocop-rspec'
+  t.requires << 'rubocop-performance'
   t.requires << 'rubocop-rake'
 end
 

data/lib/smart_core/container.rb

@@ -7,10 +7,10 @@ require 'smart_core'
 module SmartCore
   # @api public
   # @since 0.1.0
-  class Container
+  class Container # rubocop:disable Metrics/ClassLength
     require_relative 'container/version'
     require_relative 'container/errors'
-    require_relative 'container/arbitary_lock'
+    require_relative 'container/arbitrary_lock'
     require_relative 'container/key_guard'
     require_relative 'container/entities'
     require_relative 'container/definition_dsl'
@@ -18,27 +18,77 @@ module SmartCore
     require_relative 'container/registry'
     require_relative 'container/registry_builder'
     require_relative 'container/dependency_resolver'
+    require_relative 'container/dependency_watcher'
+    require_relative 'container/host'
     require_relative 'container/mixin'
 
+    class << self
+      # @param initial_container_klass [Class<SmartCore::Container>]
+      # @param container_definitions [Block]
+      # @return [SmartCore::Container]
+      #
+      # @api public
+      # @since 0.7.0
+      def define(initial_container_klass = self, &container_definitions)
+        unless initial_container_klass <= SmartCore::Container
+          raise(SmartCore::Container::ArgumentError, <<~ERROR_MESSAGE)
+            Base class should be a type of SmartCore::Container
+          ERROR_MESSAGE
+        end
+
+        Class.new(initial_container_klass, &container_definitions).new
+      end
+    end
+
     # @since 0.4.0
     include ::Enumerable
 
     # @since 0.1.0
     include DefinitionDSL
 
+    # @return [NilClass]
+    #
+    # @api private
+    # @since 0.8.1
+    NO_HOST_CONTAINER = nil
+
+    # @return [NilClass]
+    #
+    # @api private
+    # @since 0.8.1
+    NO_HOST_PATH = nil
+
     # @return [SmartCore::Container::Registry]
     #
     # @api private
     # @since 0.1.0
     attr_reader :registry
 
+    # @return [SmartCore::Container::Host]
+    #
+    # @api private
+    # @since 0.8.1
+    attr_reader :host
+
+    # @return [SmartCore::Container::DependencyWatcher]
+    #
+    # @api private
+    # @since 0.8.0
+    attr_reader :watcher
+
+    # @option host_container [SmartCore::Container, NilClass]
+    # @option host_path [String, NilClass]
     # @return [void]
     #
     # @api public
     # @since 0.1.0
-    def initialize
+    # @version 0.8.1
+    def initialize(host_container: NO_HOST_CONTAINER, host_path: NO_HOST_PATH)
+      @host = SmartCore::Container::Host.build(host_container, host_path)
       build_registry!
-      @access_lock = ArbitaryLock.new
+      @watcher = SmartCore::Container::DependencyWatcher.new(self)
+      @host_path = host_path
+      @access_lock = ArbitraryLock.new
     end
 
     # @param dependency_name [String, Symbol]
@@ -47,8 +97,16 @@ module SmartCore
     #
     # @api public
     # @sicne 0.1.0
-    def register(dependency_name, &dependency_definition)
-      thread_safe { registry.register_dependency(dependency_name, &dependency_definition) }
+    # @version 0.8.0
+    def register(
+      dependency_name,
+      memoize: SmartCore::Container::Registry::DEFAULT_MEMOIZATION_BEHAVIOR,
+      &dependency_definition
+    )
+      thread_safe do
+        registry.register_dependency(dependency_name, memoize: memoize, &dependency_definition)
+        watcher.notify(dependency_name)
+      end
     end
 
     # @param namespace_name [String, Symbol]
@@ -57,8 +115,12 @@ module SmartCore
     #
     # @api public
     # @since 0.1.0
+    # @version 0.8.0
     def namespace(namespace_name, &dependencies_definition)
-      thread_safe { registry.register_namespace(namespace_name, &dependencies_definition) }
+      thread_safe do
+        registry.register_namespace(namespace_name, self, &dependencies_definition)
+        watcher.notify(namespace_name)
+      end
     end
 
     # @param dependency_path [String, Symbol]
@@ -114,6 +176,34 @@ module SmartCore
       thread_safe { registry.keys(all_variants: all_variants) }
     end
 
+    # @param key [String, Symbol]
+    # @return [Boolean]
+    #
+    # @api public
+    # @since 0.5.0
+    def key?(key)
+      thread_safe { DependencyResolver.key?(self, key) }
+    end
+
+    # @param namespace_path [String, Symbol]
+    # @return [Boolean]
+    #
+    # @api public
+    # @since 0.5.0
+    def namespace?(namespace_path)
+      thread_safe { DependencyResolver.namespace?(self, namespace_path) }
+    end
+
+    # @param dependency_path [String, Symbol]
+    # @option memoized [NilClass, Boolean]
+    # @return [Boolean]
+    #
+    # @api public
+    # @since 0.5.0
+    def dependency?(dependency_path, memoized: nil)
+      thread_safe { DependencyResolver.dependency?(self, dependency_path, memoized: memoized) }
+    end
+
     # @option yield_all [Boolean]
     # @param block [Block]
     # @yield [dependency_name, dependency_value]
@@ -143,12 +233,47 @@ module SmartCore
     alias_method :to_h, :hash_tree
     alias_method :to_hash, :hash_tree
 
+    # @param entity_path [String]
+    # @param observer [Block]
+    # @yield [entity_path, container]
+    # @yieldparam entity_path [String]
+    # @yieldparam container [SmartCore::Container]
+    # @return [SmartCore::Container::DependencyWatcher::Observer]
+    #
+    # @api public
+    # @since 0.8.0
+    def observe(entity_path, &observer) # TODO: support for pattern-based pathes
+      thread_safe { watcher.watch(entity_path, &observer) }
+    end
+    alias_method :subscribe, :observe
+
+    # @param observer [SmartCore::Container::DependencyWatcher::Observer]
+    # @return [Boolean]
+    #
+    # @api public
+    # @since 0.8.0
+    def unobserve(observer)
+      thread_safe { watcher.unwatch(observer) }
+    end
+    alias_method :unsubscribe, :unobserve
+
+    # @param entity_path [String, Symbol, NilClass]
+    # @return [void]
+    #
+    # @api public
+    # @since 0.8.0
+    def clear_observers(entity_path = nil) # TODO: support for pattern-based pathes
+      thread_safe { watcher.clear_listeners(entity_path) }
+    end
+    alias_method :clear_listeners, :clear_observers
+
     private
 
     # @return [void]
     #
     # @api private
     # @since 0.1.0
+    # @version 0.8.1
     def build_registry!
       @registry = RegistryBuilder.build(self)
     end

data/lib/smart_core/container/{arbitary_lock.rb → arbitrary_lock.rb}

@@ -2,7 +2,7 @@
 
 # @api private
 # @since 0.1.0
-class SmartCore::Container::ArbitaryLock
+class SmartCore::Container::ArbitraryLock
   # @return [void]
   #
   # @api private

data/lib/smart_core/container/definition_dsl.rb

@@ -17,7 +17,7 @@ class SmartCore::Container
       def included(base_klass)
         base_klass.instance_variable_set(:@__container_definition_commands__, CommandSet.new)
         base_klass.instance_variable_set(:@__container_instantiation_commands__, CommandSet.new)
-        base_klass.instance_variable_set(:@__container_definition_lock__, ArbitaryLock.new)
+        base_klass.instance_variable_set(:@__container_definition_lock__, ArbitraryLock.new)
         base_klass.singleton_class.send(:attr_reader, :__container_definition_commands__)
         base_klass.singleton_class.send(:attr_reader, :__container_instantiation_commands__)
         base_klass.extend(ClassMethods)
@@ -36,7 +36,7 @@ class SmartCore::Container
       def inherited(child_klass)
         child_klass.instance_variable_set(:@__container_definition_commands__, CommandSet.new)
         child_klass.instance_variable_set(:@__container_instantiation_commands__, CommandSet.new)
-        child_klass.instance_variable_set(:@__container_definition_lock__, ArbitaryLock.new)
+        child_klass.instance_variable_set(:@__container_definition_lock__, ArbitraryLock.new)
         SmartCore::Container::DefinitionDSL::Inheritance.inherit(base: self, child: child_klass)
         child_klass.singleton_class.prepend(ClassInheritance)
         super

data/lib/smart_core/container/definition_dsl/command_set.rb

@@ -18,7 +18,7 @@ class SmartCore::Container::DefinitionDSL::CommandSet
   # @since 0.1.0
   def initialize
     @commands = []
-    @access_lock = SmartCore::Container::ArbitaryLock.new
+    @access_lock = SmartCore::Container::ArbitraryLock.new
   end
 
   # @param [SmartCore::Container::DefinitionDSL::Commands::Base]

data/lib/smart_core/container/definition_dsl/commands/definition/register.rb

@@ -36,7 +36,7 @@ module SmartCore::Container::DefinitionDSL::Commands::Definition
     # @since 0.1.0
     # @version 0.2.0
     def call(registry)
-      registry.register_dependency(dependency_name, memoize, &dependency_definition)
+      registry.register_dependency(dependency_name, memoize: memoize, &dependency_definition)
     end
 
     # @return [SmartCore::Container::DefinitionDSL::Commands::Definition::Register]

data/lib/smart_core/container/dependency_resolver.rb

@@ -22,8 +22,57 @@ module SmartCore::Container::DependencyResolver
     #
     # @api private
     # @since 0.1.0
+    # @version 0.8.1
     def fetch(container, dependency_path)
-      container.registry.resolve(dependency_path).reveal
+      container.registry.resolve(dependency_path).reveal(container)
+    end
+
+    # @param container [SmartCore::Container]
+    # @param key [String, Symbol]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.5.0
+    def key?(container, key)
+      extract(container, key)
+      true
+    rescue SmartCore::Container::ResolvingError
+      false
+    end
+
+    # @param container [SmartCore::Container]
+    # @param namespace_path [String, Symbol]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.5.0
+    def namespace?(container, namespace_path)
+      extract(container, namespace_path).is_a?(SmartCore::Container::Entities::Namespace)
+    rescue SmartCore::Container::ResolvingError
+      false
+    end
+
+    # @param container [SmartCore::Container]
+    # @param dependency_path [String, Symbol]
+    # @option memoized [NilClass, Boolean]
+    # @return [Boolean]
+    #
+    # @api private
+    # @since 0.5.0
+    def dependency?(container, dependency_path, memoized: nil)
+      entity = extract(container, dependency_path)
+
+      case
+      when memoized.nil?
+        entity.is_a?(SmartCore::Container::Entities::Dependency)
+      when !!memoized == true
+        entity.is_a?(SmartCore::Container::Entities::MemoizedDependency)
+      when !!memoized == false
+        entity.is_a?(SmartCore::Container::Entities::Dependency) &&
+          !entity.is_a?(SmartCore::Container::Entities::MemoizedDependency)
+      end
+    rescue SmartCore::Container::ResolvingError
+      false
     end
 
     # @param container [SmartCore::Container]
@@ -38,13 +87,16 @@ module SmartCore::Container::DependencyResolver
     #
     # @api private
     # @since 0.1.0
-    # @version 0.1.0
+    # @version 0.8.1
     def resolve(container, dependency_path)
       entity = container
+      host_container = container
+
       Route.build(dependency_path).each do |cursor|
         entity = entity.registry.resolve(cursor.current_path)
-        prevent_cursor_overflow!(cursor, entity)
-        entity = entity.reveal
+        prevent_ambiguous_resolving!(cursor, entity)
+        entity = entity.reveal(host_container)
+        host_container = entity.is_a?(SmartCore::Container) ? entity : nil
       end
       entity
     rescue SmartCore::Container::ResolvingError => error
@@ -53,6 +105,28 @@ module SmartCore::Container::DependencyResolver
 
     private
 
+    # @param container [SmartCore::Container]
+    # @param entity_path [String, Symbol]
+    # @return [SmartCore::Container::Entities::Base]
+    #
+    # @api private
+    # @since 0.5.0
+    # @version 0.8.1
+    def extract(container, entity_path)
+      resolved_entity = container
+      extracted_entity = container
+      host_container = container
+
+      Route.build(entity_path).each do |cursor|
+        resolved_entity = resolved_entity.registry.resolve(cursor.current_path)
+        extracted_entity = resolved_entity
+        resolved_entity = resolved_entity.reveal(host_container)
+        host_container = resolved_entity.is_a?(SmartCore::Container) ? resolved_entity : nil
+      end
+
+      extracted_entity
+    end
+
     # @param cursor [SmartCore::Container::DependencyResolver::Route::Cursor]
     # @param entity [SmartCore::Container::Entities::Base]
     # @return [void]
@@ -60,8 +134,8 @@ module SmartCore::Container::DependencyResolver
     # @raise [SmartCore::Container::ResolvingError]
     #
     # @api private
-    # @since 0.1.0
-    def prevent_cursor_overflow!(cursor, entity)
+    # @since 0.5.0
+    def prevent_ambiguous_resolving!(cursor, entity)
       if cursor.last? && entity.is_a?(SmartCore::Container::Entities::Namespace)
         raise(
           SmartCore::Container::ResolvingError.new(

data/lib/smart_core/container/dependency_watcher.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+# @api private
+# @since 0.8.0
+class SmartCore::Container::DependencyWatcher
+  require_relative 'dependency_watcher/observer'
+
+  # @param container [SmartCore::Container]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.8.0
+  def initialize(container)
+    @container = container
+    @observers = Hash.new { |h, k| h[k] = [] }
+    @access_lock = SmartCore::Container::ArbitraryLock.new
+  end
+
+  # @param entity_path [String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.8.0
+  def notify(entity_path)
+    thread_safe { notify_listeners(entity_path) }
+  end
+
+  # @param entity_path [String, Symbol]
+  # @param observer [Block]
+  # @return [SmartCore::Container::DependencyWatcher::Observer]
+  #
+  # @api private
+  # @since 0.8.0
+  def watch(entity_path, &observer) # TODO: support for pattern-based pathes
+    thread_safe { listen(entity_path, observer) }
+  end
+
+  # @param observer [SmartCore::Container::DependencyWatcher::Observer]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.8.0
+  def unwatch(observer)
+    thread_safe { remove_listener(observer) }
+  end
+
+  # @param entity_path [String, Symbol, NilClass]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.8.0
+  def clear_listeners(entity_path = nil) # TODO: support for pattern-based pathes
+    thread_safe { remove_listeners(entity_path) }
+  end
+
+  private
+
+  # @return [SmartCore::Container]
+  #
+  # @api private
+  # @since 0.8.0
+  attr_reader :container
+
+  # @return [Hash<String,SmartCore::Container::DependencyWatcher::Observer>]
+  #
+  # @api private
+  # @since 0.8.0
+  attr_reader :observers
+
+  # @param entity_path [String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.8.0
+  # @version 0.8.1
+  def notify_listeners(entity_path)
+    entity_path = indifferently_accessable_path(entity_path)
+    observers.fetch(entity_path).each(&:notify!) if observers.key?(entity_path)
+    container.host.notify_about_nested_changement(entity_path)
+  end
+
+  # @param entity_path [String, Symbol]
+  # @param observer [Proc]
+  # @return [SmartCore::Container::DependencyWatcher::Observer]
+  #
+  # @api private
+  # @since 0.8.0
+  def listen(entity_path, observer) # TODO: support for pattern-based pathes
+    raise(SmartCore::Container::ArgumentError, <<~ERROR_MESSAGE) unless observer.is_a?(Proc)
+      Observer is missing: you should provide an observer proc object (block).
+    ERROR_MESSAGE
+
+    entity_path = indifferently_accessable_path(entity_path)
+    Observer.new(container, entity_path, observer).tap { |obs| observers[entity_path] << obs }
+  end
+
+  # @param observer [SmartCore::Container::DependencyWatcher::Observer]
+  # @return [Boolean]
+  #
+  # @api private
+  # @since 0.8.0
+  def remove_listener(observer)
+    unless observer.is_a?(SmartCore::Container::DependencyWatcher::Observer)
+      raise(SmartCore::Container::ArgumentError, <<~ERROR_MESSAGE)
+        You should provide an observer object for unsubscribion
+        (an instance of SmartCore::Container::DependencyWatcher::Observer).
+      ERROR_MESSAGE
+    end
+
+    unsubscribed = false
+    observers.each_value do |observer_list|
+      if observer_list.delete(observer)
+        unsubscribed = true
+        break
+      end
+    end
+    unsubscribed
+  end
+
+  # @param entity_path [String, Symbol]
+  # @return [void]
+  #
+  # @api private
+  # @since 0.8.0
+  def remove_listeners(entity_path) # TODO: support for pattern-based pathes
+    if entity_path.nil?
+      observers.each_value(&:clear)
+    else
+      entity_path = indifferently_accessable_path(entity_path)
+      observers[entity_path].clear if observers.key?(entity_path)
+    end
+  end
+
+  # @param entity_path [String, Symbol]
+  # @return [String]
+  #
+  # @api private
+  # @since 0.8.0
+  def indifferently_accessable_path(entity_path)
+    SmartCore::Container::KeyGuard.indifferently_accessable_key(entity_path)
+  end
+
+  # @param block [Block]
+  # @return [Any]
+  #
+  # @api private
+  # @since 0.8.0
+  def thread_safe(&block)
+    @access_lock.thread_safe(&block)
+  end
+end