smart_container 0.3.0 → 0.8.0

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,8 +18,30 @@ module SmartCore
     require_relative 'container/registry'
     require_relative 'container/registry_builder'
     require_relative 'container/dependency_resolver'
+    require_relative 'container/dependency_watcher'
     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
 
@@ -35,7 +57,7 @@ module SmartCore
     # @since 0.1.0
     def initialize
       build_registry!
-      @access_lock = ArbitaryLock.new
+      @access_lock = ArbitraryLock.new
     end
 
     # @param dependency_name [String, Symbol]
@@ -44,8 +66,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]
@@ -54,8 +84,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, &dependencies_definition)
+        watcher.notify(namespace_name)
+      end
     end
 
     # @param dependency_path [String, Symbol]
@@ -102,6 +136,61 @@ module SmartCore
       thread_safe { build_registry! }
     end
 
+    # @option all_variants [Boolean]
+    # @return [Array<String>]
+    #
+    # @api public
+    # @since 0.4.0
+    def keys(all_variants: SmartCore::Container::Registry::DEFAULT_KEY_EXTRACTION_BEHAVIOUR)
+      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]
+    # @yield_param dependency_name [String]
+    # @yield_param dependency_value [Any, SmartCore::Container]
+    # @return [Enumerable]
+    #
+    # @api public
+    # @since 0.4.0
+    def each_dependency(
+      yield_all: SmartCore::Container::Registry::DEFAULT_ITERATION_YIELD_BEHAVIOUR,
+      &block
+    )
+      thread_safe { registry.each_dependency(yield_all: yield_all, &block) }
+    end
+    alias_method :each, :each_dependency
+    alias_method :each_pair, :each_dependency
+
     # @option resolve_dependencies [Boolean]
     # @return [Hash<String|Symbol,SmartCore::Container::Entities::Base|Any>]
     #
@@ -113,14 +202,56 @@ 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 [SmartCore::Container::DependencyWatcher]
+    #
+    # @api private
+    # @since 0.8.0
+    attr_reader :watcher
+
     # @return [void]
     #
     # @api private
     # @since 0.1.0
+    # @version 0.8.0
     def build_registry!
       @registry = RegistryBuilder.build(self)
+      @watcher = SmartCore::Container::DependencyWatcher.new(self)
     end
 
     # @param block [Block]

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

@@ -5,6 +5,12 @@
 module SmartCore::Container::DependencyResolver
   require_relative 'dependency_resolver/route'
 
+  # @return [String]
+  #
+  # @api private
+  # @since 0.4.0
+  PATH_PART_SEPARATOR = '.'
+
   class << self
     # @param container [SmartCore::Container]
     # @param dependency_path [String, Symbol]
@@ -20,6 +26,54 @@ module SmartCore::Container::DependencyResolver
       container.registry.resolve(dependency_path).reveal
     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]
     # @param dependency_path [String, Symbol]
     # @return [SmartCore::Container, Any]
@@ -32,12 +86,11 @@ module SmartCore::Container::DependencyResolver
     #
     # @api private
     # @since 0.1.0
-    # @version 0.1.0
     def resolve(container, dependency_path)
       entity = container
       Route.build(dependency_path).each do |cursor|
         entity = entity.registry.resolve(cursor.current_path)
-        prevent_cursor_overflow!(cursor, entity)
+        prevent_ambiguous_resolving!(cursor, entity)
         entity = entity.reveal
       end
       entity
@@ -47,6 +100,25 @@ 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
+    def extract(container, entity_path)
+      resolved_entity = container
+      extracted_entity = 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
+      end
+
+      extracted_entity
+    end
+
     # @param cursor [SmartCore::Container::DependencyResolver::Route::Cursor]
     # @param entity [SmartCore::Container::Entities::Base]
     # @return [void]
@@ -54,8 +126,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(
@@ -84,10 +156,9 @@ module SmartCore::Container::DependencyResolver
     # @api private
     # @since 0.1.0
     def process_resolving_error(dependency_path, error)
-      full_dependency_path = Route.build_path(dependency_path, error.path_part)
-      raise(SmartCore::Container::ResolvingError.new(<<~MESSAGE, path_part: full_dependency_path))
-        #{error.message} (incorrect path: "#{full_dependency_path}")
-      MESSAGE
+      full_dependency_path = Route.build_path(error.path_part)
+      message = "#{error.message} (incorrect path: \"#{full_dependency_path}\")"
+      raise(SmartCore::Container::ResolvingError.new(message, path_part: full_dependency_path))
     end
   end
 end

data/lib/smart_core/container/dependency_resolver/route.rb

@@ -2,18 +2,13 @@
 
 # @api private
 # @since 0.1.0
+# @version 0.4.0
 class SmartCore::Container::DependencyResolver::Route
   require_relative 'route/cursor'
 
   # @since 0.1.0
   include Enumerable
 
-  # @return [String]
-  #
-  # @api private
-  # @since 0.1.0
-  PATH_PART_SEPARATOR = '.'
-
   class << self
     # @param path [String, Symbol]
     # @return [SmartCore::Container::DependencyResolver::Route]
@@ -28,8 +23,9 @@ class SmartCore::Container::DependencyResolver::Route
     #
     # @api private
     # @since 0.1.0
+    # @version 0.4.0
     def build_path(*path_parts)
-      path_parts.join(PATH_PART_SEPARATOR)
+      path_parts.join(SmartCore::Container::DependencyResolver::PATH_PART_SEPARATOR)
     end
   end
 
@@ -50,9 +46,10 @@ class SmartCore::Container::DependencyResolver::Route
   #
   # @api private
   # @since 0.1.0
+  # @version 0.4.0
   def initialize(path)
     @path = path
-    @path_parts = path.split(PATH_PART_SEPARATOR).freeze
+    @path_parts = path.split(SmartCore::Container::DependencyResolver::PATH_PART_SEPARATOR).freeze
     @size = @path_parts.size
   end
 

data/lib/smart_core/container/dependency_watcher.rb

@@ -0,0 +1,149 @@
+# 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 { |k, v| k[v] = [] }
+    @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
+  def notify_listeners(entity_path)
+    entity_path = indifferently_accessable_path(entity_path)
+    observers.fetch(entity_path).each(&:notify!) if observers.key?(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