nxt_registry 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b8c5142f31e6c1d053ea403da1bdbe76b800afb40648a7660a245809cbd4b71
-  data.tar.gz: 7bd26fcda427f8fb20033e0ee9d39783c84849fd26d9f70cbee5c32ef5676f72
+  metadata.gz: a68b0acda862ba1abd86c05b6965258563e4c091bd0ae49012f92d5833ba1416
+  data.tar.gz: b6d55555232b4fc6fbbd842d538f0732fe5232369be6724525d6723465d6776b
 SHA512:
-  metadata.gz: 8ab7450365d3cb0ece3ae837f42c981d986441ce571cf5122d2cda68925192e20da3fa6fff1e33b379270459edb63715c76e1049043346d423471702df038f38
-  data.tar.gz: dd6a35358dc963e63751ac3f34c80ab3c7a665c9551968f8eb8d336d0be6db0aa4c4ce4723af50e06dc79b129b7f310e6fe402e4667c509a80a102265821bd59
+  metadata.gz: 25799005260cfb9bbda4264200c0cc1ea80e6fde0f7671048413f8835d1035f4fa27179a0ec047ca5d555600ec7f0d82cc9ee15a58934159d8b382896300e6af
+  data.tar.gz: 994fda385124d529b3edc72bfd4c2e2a2186e8e79918b0e1029f0f7ed20bc921024d30f60c0d4df6cc8227fe6738a31a049dc1ff29ad814c1b71a9ba9b60ef4e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    nxt_registry (0.1.2)
+    nxt_registry (0.1.3)
       activesupport
 
 GEM

data/README.md

@@ -1,7 +1,7 @@
 # NxtRegistry
 
-NxtRegistry is a simple implementation of the container pattern. It allows you to register and resolve values.
-It allows to register and resolve values in nested structures by allowing to nest registries into each other.
+NxtRegistry is a simple implementation of the container pattern. It allows you to register and resolve values in nested 
+structures by allowing nesting registries into each other. In theory this can be indefinitely deep.
 
 ## Installation
 
@@ -21,80 +21,158 @@ Or install it yourself as:
 
 ## Usage
 
+```ruby
+class Example
+  include NxtRegistry
+  
+  def passengers
+    @passengers ||= begin
+      registry :from do
+        nested :to do
+          nested :via, memoize: true, call: true, default: -> { [] } do
+            attrs %i[train car plane horse] # restrict the attributes that can be registered
+            resolver ->(value) { value } # do something with your registered value here
+            transform_keys ->(key) { key.upcase } # transform keys 
+          end
+        end
+      end
+    end
+  end
+end
+
+example = Example.new
+# Based on the naming of the registry and its nesting you are provided with a simple interface 
+# that allows you to resolve and register values by name
+ 
+# Register an array with a value by calling the accessor with a key, value pair 
+example.passengers.from(:a).to(:b).via(:train, ['Andy']) # => ['Andy']
+
+# In case you try to register the same key again you will get an error
+example.passengers.from(:a).to(:b).via(:train, ['Andy'])
+# => NxtRegistry::Errors::KeyAlreadyRegisteredError 
+# (Key 'train' already registered in registry 'from.to.via')
+# NxtRegistry::Errors::KeyAlreadyRegisteredError inherits from KeyError
+
+# You can force values on the registry by using the bang method
+example.passengers.from(:a).to(:b).via!(:train, ['Andreas'])  
+
+# Similarly you can try to resolve values softly 
+# (meaning no KeyNotRegisteredError will be raised when nothing was registered)
+example.passengers.from(:a).to(:b).via!(:train) 
+# Since there is a default defined for this registry, it does not make any sense 
+#  since there is always a value. But you get the point...
+
+# Resolve values by calling the accessor with the key only
+# In this case the default is returned because nothing was registered yet 
+example.passengers.from(:a).to(:b).via(:hyperloop) # []
+
+# Appending values to a default array
+example.passengers.from(:a).to(:b).via(:car) << 'Lütfi' # => ['Lütif']
+example.passengers.from(:a).to(:b).via(:plane) += %w[Nils Rapha]
+example.passengers.from(:a).to(:b).via(:plane) # => ['Nils', 'Rapha']
+
+```
+
+
+```ruby
+class OtherExample
+  extend NxtRegistry
+
+  # By passing a block to :registry you can directly register your values inline 
+  REGISTRY = registry(:errors) do
+    # procs are called directly if not defined otherwise 
+    register(KeyError, ->(error) { puts 'KeyError handler' } )
+    register(ArgumentError, ->(error) { puts 'ArgumentError handler' } )
+  end
+end
+
+# Instead of using the name of the registry, you can also always call register and resolve on the 
+# level where you want to register or resolve values. Equivalently to the named interface you can 
+# use register! and resolve! to softly resolve or forcfully register values.  
+OtherExample::REGISTRY.resolve(KeyError)
+# KeyError handler
+# => nil
+
+```
+
 ### Restrict attributes to a certain set
 
 Use `attrs` to restrict which attributes can be registered on a specific level.
 
+```ruby
+registry :example, attrs: %w[one two three]
+```
+
 ### Default values
 
 Use `default` to register a default value that will be resolved in case an attribute was not registered.
 
+```ruby
+registry :example, default: ->(value) { 'default' }
+```
+
 ### Blocks
 
 When you register a block value that can be called, tt will automatically be called when you resolve the value. 
 If that's not what you want, you can configure your registry (on each level) not to call blocks directly by defining `call false`
 
+```ruby
+registry :example, call: false do
+  register(:one, ->(value) { 'Not called when resolved' } )
+end
+```
+
 ### Memoize
 
 Values are memoized per default. Switch it off with `default false`
 
+```ruby
+registry :example, memoize: false do
+  register(:one, -> { Time.current } )
+end
+
+registry.resolve(:one)
+# => 2020-01-02 23:56:15 +0100
+registry.resolve(:one)
+# => 2020-01-02 23:56:17 +0100
+registry.resolve(:one)
+# => 2020-01-02 23:56:18 +0100
+```
+
 ### Resolver
 
 You can register a resolver block if you want to lay hands on your values after they have been resolved.
 
+```ruby
+registry :example do
+  resolver ->(value) { value * 2 }
+  register(:one, 1)
+end
+
+registry.resolve(:one)
+# => 2
+```
+
 ### Transform keys
 
 NxtRegistry uses a plain ruby hash to store values internally. Per default all keys used are transformed with `&:to_s`.
 Thus you can use symbols or strings to register and resolve values. If it's not what you want, switch it off with `transform_keys false`
-or define your own key transformer by assigning a block `transform_keys ->(key) { key.upcase }`
-
-### Customize :raise_key_already_registered_error and :raise_key_not_registered_error
-
-Customize what kind of errors are being raised in case a of a key was not registered or was already registered.    
- 
+or define your own key transformer by assigning a block to transform_keys: `transform_keys ->(key) { key.upcase }`
 
 ```ruby
-class MyClass
-  include NxtRegistry
-  
-  def passengers
-    @passengers ||= begin
-      registry :from do
-        nested :to do
-          nested :via, memoize: true, call: true, default: -> { [] }, attrs: %i[train car plane horse] do
-            resolver ->(value) { value } # do something with your registered value here
-            transform_keys ->(key) { key.upcase } # transform keys 
-          end
-        end
-      end
-    end
-  end
+registry :example do
+  transform_keys ->(key) { key.to_s.downcase }
+  register(:bombshell, 'hanna')
 end
 
-subject = MyClass.new
-subject.passengers.from(:a).to(:b).via(:train) # => []
-subject.passengers.from(:a).to(:b).via(:train) << 'Andy'
-subject.passengers.from(:a).to(:b).via(:car) << 'Lütfi'
-subject.passengers.from(:a).to(:b).via(:plane) << 'Nils'
-subject.passengers.from(:a).to(:b).via(:plane) << 'Rapha'
-subject.passengers.from(:a).to(:b).via(:plane) # => ['Nils', 'Rapha']
-
-subject.passengers.from(:a).to(:b).via(:hyperloop) # => KeyError
-
-
-class MyClass
-  extend NxtRegistry
-
-  REGISTRY = registry(:errors) do 
-    register(KeyError, ->(error) { puts 'KeyError handler' } )
-  end
-end
+registry.resolve('BOMBSHELL')
+# => 'hanna'
+```
 
-MyClass::REGISTRY.resolve(KeyError)
-# KeyError handler
-# => nil
+### Customize registry errors
 
-```
+You can also customize what kind of errors are being raised in case a of a key was not registered or was already registered.
+by providing values for `raise_key_already_registered_error` and `raise_key_not_registered_error`
 
 ## Development
 

data/lib/nxt_registry/registry.rb

@@ -4,7 +4,7 @@ module NxtRegistry
       @name = name
       @parent = options[:parent]
       @is_leaf = true
-      @namespace = [parent, self].compact.map(&:name).join('.')
+      @namespace = parent ? name.to_s.prepend("#{parent.send(:namespace)}.") : name.to_s
       @config = config
       @options = options
       @store = {}
@@ -17,6 +17,7 @@ module NxtRegistry
     attr_reader :name
 
     def nested(name, **options, &config)
+      # TODO: Ensure that nesting is included in defined attrs
       options = options.merge(parent: self)
 
       if default.is_a?(Blank)
@@ -112,6 +113,12 @@ module NxtRegistry
       end
     end
 
+    def to_s
+      "Registry[#{name}] -> #{store.to_s}"
+    end
+
+    alias_method :inspect, :to_s
+
     private
 
     attr_reader :namespace, :parent, :config, :store, :options

data/lib/nxt_registry/version.rb

@@ -1,3 +1,3 @@
 module NxtRegistry
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_registry
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Andreas Robecke
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-01-02 00:00:00.000000000 Z
+date: 2020-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport