smart_container 0.3.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 919cbfa847aa6931a64cf70c07269a0883ac0b5f47e9b84243854b0ea626f49e
-  data.tar.gz: b9fcfbf5060a973bf1aa8e81d8a78cbdabf243e585dea583e64904e698c094dc
+  metadata.gz: 6670714cdeb503df6debb42135ee26283aef48a012fcf2469487668390a675f3
+  data.tar.gz: ba0ad291f05bdebb5d5af7fc46554c30c0748753243e04ac6277abf74886acb6
 SHA512:
-  metadata.gz: 282c7f32da7c8029518b72f94b1047ed71046db44b0e18c9eef2557158bbf3ad97bb5ed658af9a836105964175fa2fd5a5b6ddb0568700b39ed471e7b6ec4c28
-  data.tar.gz: bfabb455faa37954f0700d2f910e6de93ed4194bb9bb63d45918af7e81de92a5f07f3edf503c922a363d682d6a227cad64a5e5f4c53b355db0b8018757397bb4
+  metadata.gz: 29b1566aaff6a6227ed13a03a0b65110ce319c4b08bccc50b8c346793cb258174ee611fa19e3950e339049ab50b5819fc31ae6164b2e6d715c8a51d72a29a44f
+  data.tar.gz: cd38836e86ef48c860e58e55af5a30b8f3babdb7724658f96dee7a42ee953a122667688b29bdbb50aeccb94fc4026c1dc17d922524f21a32b20ab67ad7f3ca58

data/.rubocop.yml

@@ -5,11 +5,11 @@ inherit_gem:
     - lib/rubocop.rspec.yml
 
 AllCops:
-  TargetRubyVersion: 2.4.9
+  TargetRubyVersion: 2.7.1
   Include:
     - lib/**/*.rb
     - spec/**/*.rb
     - Gemfile
     - Rakefile
-    - siege.gemspec
+    - smart_container.gemspec
     - bin/console

data/.travis.yml

@@ -1,28 +1,22 @@
 ---
 language: ruby
 cache: bundler
+os: linux
+dist: xenial
 before_install:
-- gem install bundler -v 2.1.2
+- gem install bundler
 script:
 - bundle exec rake rubocop
 - bundle exec rake rspec
 jobs:
   fast_finish: true
   include:
-  - rvm: 2.4.9
-    os: [linux, osx]
-  - rvm: 2.5.7
-    os: [linux, osx]
-  - rvm: 2.6.5
-    os: [linux, osx]
-  - rvm: 2.7.0
-    os: [linux, osx]
+  - rvm: 2.4.10
+  - rvm: 2.5.8
+  - rvm: 2.6.6
+  - rvm: 2.7.1
   - rvm: ruby-head
-    os: [linux, osx]
   - rvm: jruby-head
-    os: [linux, osx]
   allow_failures:
   - rvm: ruby-head
-    os: [linux, osx]
   - rvm: jruby-head
-    os: [linux, osx]

data/CHANGELOG.md

@@ -1,6 +1,37 @@
 # Changelog
 All notable changes to this project will be documented in this file.
 
+## [0.8.0] - 2020-07-08
+### Added
+- An ability to observe dependency re-registrations:
+  - `#observe(path, &observer) # => observer object` - listen specific dependency path;
+  - `#unobserve(observer)` - unsubscribe concrete observer object;
+  - `#clear_observers(path = nil)` - unsubscribe specific listenr or all listeners (`nil` parameter);
+
+## [0.7.0] - 2020-06-20
+### Added
+- `SmartCore::Container.define {}` - an ability to avoid explicit class definition that allows
+  to create container instances from an anonymous container class imidietly
+
+## [0.6.0] - 2020-01-12
+### Added
+- Missing memoization flag `:memoize` for runtime-based dependency registration:
+  - `memoize: false` by default;
+  - signature: `SmartCore::Container#register(dependency_name, memoize: false, &dependency)`
+
+## [0.5.0] - 2020-01-07
+### Added
+- Key predicates (`#key?(key)`, `#dependency?(path, memoized: nil/true/false)`, `#namespace?(path)`);
+
+## [0.4.0] - 2020-01-06
+### Added
+- `#keys(all_variants: false)` - return a list of dependency keys
+  (`all_variants: true` is mean "including namespace kaeys");
+- `#each_dependency(yield_all: false) { |key, value| }` - iterate over conteiner's dependencies
+  (`yield_all: true` will include nested containers to iteration process);
+### Fixed
+- `SmartCore::Container::ResolvingError` class has incorrect message attribute name;
+
 ## [0.3.0] - 2020-01-05
 ### Changed
 - Dependency resolving is not memoized by default (previously: totally memoized 😱);

data/Gemfile.lock

@@ -1,83 +1,98 @@
 PATH
   remote: .
   specs:
-    smart_container (0.3.0)
-      smart_engine (~> 0.2)
+    smart_container (0.8.0)
+      smart_engine (~> 0.5)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    armitage-rubocop (0.78.0)
-      rubocop (= 0.78.0)
+    activesupport (6.0.2.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2)
+    armitage-rubocop (0.81.0)
+      rubocop (= 0.81.0)
       rubocop-performance (= 1.5.2)
-      rubocop-rails (= 2.4.1)
-      rubocop-rake (= 0.5.0)
-      rubocop-rspec (= 1.37.1)
+      rubocop-rails (= 2.5.2)
+      rubocop-rake (= 0.5.1)
+      rubocop-rspec (= 1.38.1)
     ast (2.4.0)
     coderay (1.1.2)
+    concurrent-ruby (1.1.6)
     diff-lcs (1.3)
     docile (1.3.2)
+    i18n (1.8.2)
+      concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.4)
-    json (2.3.0)
-    method_source (0.9.2)
+    method_source (1.0.0)
+    minitest (5.14.0)
     parallel (1.19.1)
-    parser (2.7.0.1)
+    parser (2.7.1.0)
       ast (~> 2.4.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rack (2.0.8)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rack (2.2.2)
     rainbow (3.0.0)
     rake (13.0.1)
+    rexml (3.2.4)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
       rspec-mocks (~> 3.9.0)
     rspec-core (3.9.1)
       rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.0)
+    rspec-expectations (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-mocks (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.2)
-    rubocop (0.78.0)
+    rubocop (0.81.0)
       jaro_winkler (~> 1.5.1)
       parallel (~> 1.10)
-      parser (>= 2.6)
+      parser (>= 2.7.0.1)
       rainbow (>= 2.2.2, < 4.0)
+      rexml
       ruby-progressbar (~> 1.7)
-      unicode-display_width (>= 1.4.0, < 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
     rubocop-performance (1.5.2)
       rubocop (>= 0.71.0)
-    rubocop-rails (2.4.1)
+    rubocop-rails (2.5.2)
+      activesupport
       rack (>= 1.1)
       rubocop (>= 0.72.0)
-    rubocop-rake (0.5.0)
+    rubocop-rake (0.5.1)
       rubocop
-    rubocop-rspec (1.37.1)
+    rubocop-rspec (1.38.1)
       rubocop (>= 0.68.1)
     ruby-progressbar (1.10.1)
-    simplecov (0.17.1)
+    simplecov (0.18.5)
       docile (~> 1.1)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.2)
-    smart_engine (0.2.0)
-    unicode-display_width (1.6.0)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.2)
+    smart_engine (0.7.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.7)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.7.0)
+    zeitwerk (2.3.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  armitage-rubocop (~> 0.78)
+  armitage-rubocop (~> 0.81)
   bundler (~> 2.1)
-  pry (~> 0.12)
+  pry (~> 0.13)
   rake (~> 13.0)
   rspec (~> 3.9)
-  simplecov (~> 0.17)
+  simplecov (~> 0.18)
   smart_container!
 
 BUNDLED WITH
-   2.1.2
+   2.1.4

data/README.md

@@ -22,7 +22,27 @@ require 'smart_core/container'
 
 ---
 
-## Synopsis (demo)
+## Table of cotnents
+
+- [Functionality](#functionality)
+  - [container class creation](#container-class-creation)
+  - [mixin](#mixin)
+  - [container instantiation and dependency resolving](#container-instantiation-and-dependency-resolving)
+  - [runtime-level dependency/namespace registration](#runtime-level-dependencynamespace-registration)
+  - [container keys (dependency names)](#container-keys-dependency-names)
+  - [key predicates](#key-predicates)
+  - [state freeze](#state-freeze)
+  - [reloading](#reloading)
+  - [hash tree](#hash-tree)
+  - [explicit class definition](#explicit-class-definition)
+  - [dependency changement observing](#dependency-changement-observing)
+- [Roadmap](#roadmap)
+
+---
+
+## Functionality
+
+#### container class creation
 
 ```ruby
 class Container < SmartCore::Container
@@ -41,20 +61,279 @@ class Container < SmartCore::Container
   # dependencies are not memoized by default (memoize: false)
   register(:random) { rand(1000) }
 end
+```
+
+---
+
+#### mixin
+
+```ruby
+# full documentaiton is coming;
+
+class Application
+  include SmartCore::Container::Mixin
+
+  dependencies do
+    namespace(:database) do
+      register(:cache) { MemcachedClient.new }
+    end
+  end
+end
+
+# access:
+Application.container
+Application.new.container # NOTE: the same instance as Application.container
+```
+
+---
 
+#### container instantiation and dependency resolving
+
+```ruby
 container = Container.new # create container instance
+```
 
+```ruby
 container['database.resolver'] # => #<SomeDatabaseResolver:0x00007f0f0f1d6332>
 container['database.cache.redis'] # => #<RedisClient:0x00007f0f0f1d0158>
 container['logger'] # => #<Logger:0x00007f5f0f2f0158>
 
+container.resolve('logger') # #resolve(path) is an alias for #[](path)
+
 # non-memoized dependency
 container['random'] # => 352
 container['random'] # => 57
+
+# trying to resolve a namespace as dependency
+container['database'] # => SmartCore::Container::ResolvingError
+
+# but you can fetch any depenendency type (internal containers and values) via #fetch
+container.fetch('database') # => SmartCore::Container (nested container)
+container.fetch('database.resolver') # => #<SomeDatabaseResolver:0x00007f0f0f1d6332>
+```
+
+---
+
+#### runtime-level dependency/namespace registration
+
+```ruby
+container.namespace(:api) do
+  register(:provider) { GoogleProvider } # without memoization
+end
+
+container.register('game_api', memoize: true) { 'overwatch' } # with memoization
+
+container['api.provider'] # => GoogleProvider
+container['game_api'] # => 'overwatch'
+```
+
+---
+
+#### container keys (dependency names):
+
+```ruby
+# get dependnecy keys (only dependencies)
+container.keys
+# => result:
+[
+  'database.resolver',
+  'database.cache.memcached',
+  'database.cache.redis',
+  'logger',
+  'random'
+]
+```
+```ruby
+# get all keys (namespaces and dependencies)
+container.keys(all_variants: true)
+# => result:
+[
+  'database', # namespace
+  'database.resolver',
+  'database.cache', # namespace
+  'database.cache.memcached',
+  'database.cache.redis',
+  'logger',
+  'random'
+]
+```
+
+---
+
+#### key predicates
+
+- `key?(key)` - has dependency or namespace?
+- `namespace?(path)` - has namespace?
+- `dependency?(path)` - has dependency?
+- `dependency?(path, memoized: true)` - has memoized dependency?
+- `dependency?(path, memoized: false)` - has non-memoized dependency?
+
+```ruby
+container.key?('database') # => true
+container.key?('database.cache.memcached') # => true
+
+container.dependency?('database') # => false
+container.dependency?('database.resolver') # => true
+
+container.namespace?('database') # => true
+container.namespace?('database.resolver') # => false
+
+container.dependency?('database.resolver', memoized: true) # => true
+container.dependency?('database.resolver', memoized: false) # => false
+
+container.dependency?('random', memoized: true) # => false
+container.dependency?('random', memoized: false) # => true
 ```
 
 ---
 
+#### state freeze
+
+- state freeze (`#freeze!`, `.#frozen?`):
+
+```ruby
+# documentation is coming;
+```
+
+---
+
+#### reloading
+
+- reloading (`#reload!`):
+
+```ruby
+# documentation is coming;
+```
+
+---
+
+#### hash tree
+
+- hash tree (`#hash_tree`, `#hash_tree(resolve_dependencies: true)`):
+
+```ruby
+# documentation is coming;
+```
+
+---
+
+#### explicit class definition
+
+- `SmartCore::Container.define` - avoid explicit class definition (allows to create container instance from an anonymous container class immidietly):
+
+```ruby
+# - create from empty container class -
+
+AppContainer = SmartCore::Container.define do
+  namespace :database do
+    register(:logger) { Logger.new }
+  end
+end # => an instance of Class<SmartCore::Container>
+
+AppContainer.resolve('database.logger') # => #<Logger:0x00007f5f0f2f0158>
+AppContainer['database.logger'] # => #<Logger:0x00007f5f0f2f0158>
+```
+
+```ruby
+# - create from another container class with a custom sub-definitions -
+
+class BasicContainer < SmartCore::Container
+  namespace(:api) do
+    register(:client) { Kickbox.new }
+  end
+end
+
+AppContainer = BasicContainer.define do
+  register(:db_driver) { Sequel }
+end
+# --- or ---
+AppContainer = SmartCore::Container.define(BasicContainer) do
+  register(:db_driver) { Sequel }
+end
+
+AppContainer['api.client'] # => #<Kickbox:0x00007f5f0f2f0158> (BasicContainer dependency)
+AppContainer['db_driver'] # => Sequel (AppContainer dependency)
+```
+
+---
+
+#### dependency changement observing
+
+- features and limitations:
+  - you can subscribe only on container instances (on container instance changements);
+  - at this moment only the full entity path patterns are supported (pattern-based pathes are not supported yet);
+  - you can subscribe on namespace changements (when the full namespace is re-registered) and dependency changement (when some dependency has been changed);
+  - `#observe(path, &observer) => observer` - subscribe a custom block to dependency changement events (your proc will be invoked with `|path, container|` attributes);
+  - `#unobserve(observer)` - unsubscribe concrete observer from dependency observing (returns `true` (unsubscribed) or `false` (nothing to unsubscribe));
+  - `#clear_observers(entity_path = nil)` - unsubscribe all observers from concrete path or from all pathes (`nil` parameters);
+- aliases:
+  - `#observe` => `#subscribe`;
+  - `#unobserve` => `#unsubscribe`;
+  - `#clear_observers` => `#clear_listeners`;
+
+```ruby
+container = SmartCore::Container.define do
+  namespace(:database) do
+    register(:stats) { 'stat_db' }
+  end
+end
+```
+
+```ruby
+# observe entity change
+entity_observer = container.observe('database.stats') do |dependency_path, container|
+  puts "changed => '#{container[dependency_path]}'"
+end
+
+# observe namespace change
+namespace_observer = container.observe('database') do |namespace_path, container|
+  puts "changed => '#{namespace_path}'"
+end
+```
+
+```ruby
+container.register('database.stats') { 'kek' } # => invokes entity_observer and outputs "changed! => 'kek'"
+container.namespace('database') {} # => invoks namespace_observer and outputs "changed => 'database'"
+
+container.unobserve(observer) # unsubscribe entity_observer from dependency changement observing;
+container.clear_observers # unsubscribe all observers
+
+container.register('database.stats') { 'kek' } # no one to listen this changement... :)
+container.namespace('database') {} # no one to listen this changement... :)
+```
+
+---
+
+## Roadmap
+
+- pattern-based pathes in dependency changement observing;
+
+```ruby
+container.observe('path.*') { puts 'kek!' } # subscribe to all changements in `path` namespace;
+```
+
+- support for instant dependency registration:
+
+```ruby
+# common (dynamic) way:
+register('dependency_name') { dependency_value }
+
+# instant way:
+register('dependency_name', dependency_value)
+```
+
+- support for memoization ignorance during dependency resolving:
+
+```ruby
+resolve('logger', :allocate) # Draft
+```
+
+- container composition;
+
+- support for fallback block in `.resolve` operation (similar to `Hash#fetch` works);
+
+---
+
 ## Contributing
 
 - Fork it ( https://github.com/smart-rb/smart_container/fork )