nxt_registry 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6851c2c3d6dde7438aa6abe438153d4126ea962f948d472a37d8b958830390f3
-  data.tar.gz: '02158d50dd9af0686bd4427e1c41853dca588e686b9a02381263c94700093398'
+  metadata.gz: 84faa74573904a66ff0f574195ef5ab7e74508d097f04d1e7f43afcfe4867432
+  data.tar.gz: 8f5c04f6eef2f3b7328567d2b1e49fe9e862d915b572e18fdefd32cb71c24fc2
 SHA512:
-  metadata.gz: 04c65be146020a7e3c1e1fa6587cdb9efb0c4b2ab6d76741855fe99a0246e4a5ace755c3184678164f388d41a45ddc6a03c39298c0038ecf13e454f77a5deb74
-  data.tar.gz: f992919cf0d07da41e411b7dff32410678b664f4a12a47e350e0d51e239c6864eaeb549aca4518eae1f122640b99274897e6bc4b39bb6889634e6a32ee137931
+  metadata.gz: 293d5d1d418152c704ea04aaff4dd392b901c40a9460f1858e5cf6581a0c6fe58041bbe163b8aff3fbcdd9848638f7715e87046b14666f5111677c5241d67eea
+  data.tar.gz: 0475b0d48a589d90ff548d2c7f414bab38e5360fb46cafee35a29e83203a72fcd8fbce4870fbd7862b182ac38558f48567417808c5d400f4a728ff7dbf353a53

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+# v0.3.0 2020-09-10
+
+### Breaking Changes
+ 
+- Toggled interface for resolve(!) and register(!)
+- Allow to register values in nested registries
+- Rename nested method into level
+- Provide registry readers
+- Remove Singleton extension
+- Allow to resolve paths
+- Pass key to default block when it takes an argument
+
+[Compare v0.2.1...v0.3.0](https://github.com/nxt-insurance/nxt_registry/compare/v0.2.1...v0.3.0)
+
 # v0.2.1 2020-08-14
 
 ### Fixed

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    nxt_registry (0.2.1)
+    nxt_registry (0.3.0)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.2)
+    activesupport (6.0.3.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -19,7 +19,7 @@ GEM
     i18n (1.8.5)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
-    minitest (5.14.1)
+    minitest (5.14.2)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)

data/README.md

@@ -2,8 +2,8 @@
 
 # NxtRegistry
 
-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.
+`NxtRegistry` is a simple implementation of the container pattern. It allows you to register and resolve values in nested 
+structures.
 
 ## Installation
 
@@ -23,61 +23,28 @@ Or install it yourself as:
 
 ## Usage
 
-### Instance Level
+### Simple use case
+
+## Instance Level
+
+To use `NxtRegistry` on an instance level simply include it and build registries like so: 
 
 ```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
+  registry :languages do
+    register(:ruby, 'Stone')
+    register(:python, 'Snake')
+    register(:javascript, 'undefined')
   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']
-
+example.registry(:languages).resolve(:ruby) # => 'Stone'
 ```
 
-Alternatively you can create an instance of NxtRegistry::Registry.new('name', **options, &config)
+Alternatively you can also create instances of `NxtRegistry::Registry`
 
 ```ruby
 registry = NxtRegistry::Registry.new do
@@ -90,52 +57,90 @@ registry.resolve(:aki) # => 'Aki'
 
 ```
 
-### Class Level
+## Class Level
+
+You can register registries on the class level simply by extending your class with `NxtRegistry`
 
 ```ruby
-class SimpleExample
-  # By extending NxtRegistry::Singleton you get a super simple class level interface to an underlying instance of a :registry
-  extend NxtRegistry::Singleton
-  
-  registry do
-    # procs are called directly if not defined otherwise 
+class OtherExample
+  extend NxtRegistry
+ 
+  registry(:errors) do
     register(KeyError, ->(error) { puts 'KeyError handler' } )
     register(ArgumentError, ->(error) { puts 'ArgumentError handler' } )
-    # Custom key error handlers
-    on_key_already_registered ->(key) { raise "Key was already registered dude: #{key}" }
-    on_key_not_registered ->(key) { raise "Key was never registered dude: #{key}" }
   end
+
+  registry(:country_codes) do
+    register(:germany, :de)
+    register(:england, :uk)
+    register(:france, :fr)
+  end 
 end
-  
-SimpleExample.resolve(KeyError)
-# Alternatively: SimpleExample.registry.resolve(KeyError) 
-# Or: SimpleExample.instance.resolve(KeyError) 
+
+OtherExample.registry(:errors).resolve(KeyError)
 # KeyError handler
 # => nil
-
+OtherExample.registry(:country_codes).resolve(:germany)
+# => :de
 ```
+### Readers
+
+Access your defined registries with the `registry(:country_code)` method.
+
+### Nesting registries
+
+You can also simply nest registries like so:
 
 ```ruby
-class OtherExample
+class Nested
   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' } )
+  registry :developers do
+    register(:frontend) do
+      register(:igor, 'Igor')
+      register(:ben, 'Ben')
+    end
+    
+    register(:backend) do
+      register(:rapha, 'Rapha')
+      register(:aki, 'Aki')
+    end
   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
-
+Nested.registry(:developers).resolve(:frontend, :igor)
+# => 'Igor'
 ```
 
+
+### Defining specific nesting levels of a registry
+
+Another feature of `NxtRegistry` is that you can define the nesting levels for a registry. Levels allow you to dynamically 
+register values within the defined levels. This means that on any level the registry will resolve to another registry and 
+you can register values into a deeply nested structure.  
+
+```ruby
+class Layer
+  extend NxtRegistry
+  
+  registry :from do
+    level :to do
+      level :via
+    end  
+  end
+end
+
+Layer.registry(:from) # => Registry[from]
+
+Layer.registry(:from).resolve(:munich) # => Registry[to] -> {}
+Layer.registry(:from).resolve(:amsterdam) # => Registry[to] -> {}
+Layer.registry(:from).resolve(:any_key) # => Registry[to] -> {}
+
+Layer.registry(:from).resolve(:munich, :amsterdam) # => Registry[via] -> {}
+Layer.registry(:from).resolve(:munich, :amsterdam).register(:train, -> { 'train' })
+Layer.registry(:from).resolve(:munich, :amsterdam, :train) #  => 'train'
+``` 
+
 ### Restrict attributes to a certain set
 
 Use `attrs` to restrict which attributes can be registered on a specific level.
@@ -197,9 +202,10 @@ registry.resolve(:one)
 
 ### 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 to transform_keys: `transform_keys ->(key) { key.upcase }`
+`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 to transform_keys: 
+`transform_keys ->(key) { key.upcase }`
 
 ```ruby
 registry :example do

data/lib/nxt_registry.rb

@@ -3,17 +3,30 @@ require "nxt_registry/version"
 require "nxt_registry/blank"
 require "nxt_registry/attribute"
 require "nxt_registry/errors"
-require "nxt_registry/nested_registry_builder"
+require "nxt_registry/registry_builder"
 require "nxt_registry/registry"
 require "nxt_registry/recursive_registry"
-require "nxt_registry/singleton"
 
 module NxtRegistry
   def registry(name, **options, &config)
-    Registry.new(name, **options, &config)
+    return registries.fetch(name) if registries.key?(name)
+
+    registry = Registry.new(name, **options, &config)
+    registries[name] ||= registry
+    registry
   end
 
   def recursive_registry(name, **options, &config)
-    RecursiveRegistry.new(name, **options, &config)
+    return registries.fetch(name) if registries.key?(name)
+
+    registry = RecursiveRegistry.new(name, **options, &config)
+    registries[name] ||= registry
+    registry
+  end
+
+  private
+
+  def registries
+    @registries ||= {}
   end
 end

data/lib/nxt_registry/recursive_registry.rb

@@ -18,7 +18,7 @@ module NxtRegistry
     attr_reader :options, :config, :level
 
     def set_nested_builder_as_default
-      self.default = NestedRegistryBuilder.new do
+      self.default = RegistryBuilder.new do
         RecursiveRegistry.new("level_#{(level + 1)}", **options.merge(level: (level + 1)), &config)
       end
     end

data/lib/nxt_registry/registry.rb

@@ -16,25 +16,35 @@ module NxtRegistry
 
     attr_reader :name
 
-    def nested(name, **options, &config)
-      # TODO: Ensure that nesting is included in defined attrs
+    def level(name, **options, &config)
       options = options.merge(parent: self)
 
       if default.is_a?(Blank)
         self.is_leaf = false
 
-        self.default = NestedRegistryBuilder.new do
+        self.default = RegistryBuilder.new do
           Registry.new(name, **options, &config)
         end
 
+        # Call the builder once to guarantee we do not create a registry with a broken setup
         default.call
-      elsif default.is_a?(NestedRegistryBuilder)
+      elsif default.is_a?(RegistryBuilder)
         raise ArgumentError, 'Multiple nestings on the same level'
       else
         raise ArgumentError, 'Default values cannot be defined on registries that nest others'
       end
     end
 
+    def registry(name, **options, &config)
+      options = options.merge(parent: self)
+      register(name, Registry.new(name, **options, &config))
+    end
+
+    def registry!(name, **options, &config)
+      options = options.merge(parent: self)
+      register!(name, Registry.new(name, **options, &config))
+    end
+
     def attr(name)
       key = transformed_key(name)
       raise KeyError, "Attribute #{key} already registered in #{namespace}" if attrs[key]
@@ -49,20 +59,40 @@ module NxtRegistry
       args.each { |name| attr(name) }
     end
 
-    def register(key, value)
-      __register(key, value, raise: true)
+    def register(key = Blank.new, value = Blank.new, **options, &block)
+      if block_given?
+        if value.is_a?(Blank)
+          registry(key, **options, &block)
+        else
+          raise_register_argument_error
+        end
+      else
+        __register(key, value, raise: true)
+      end
     end
 
-    def register!(key, value)
-      __register(key, value, raise: false)
+    def register!(key = Blank.new, value = Blank.new, **options, &block)
+      if block_given?
+        if value.is_a?(Blank)
+          registry!(key, **options, &block)
+        else
+          raise_register_argument_error
+        end
+      else
+        __register(key, value, raise: false)
+      end
     end
 
-    def resolve(key)
-      __resolve(key, raise: true)
+    def resolve!(*keys)
+      keys.inject(self) do |current_registry, key|
+        current_registry.send(:__resolve, key, raise: true)
+      end
     end
 
-    def resolve!(key)
-      __resolve(key, raise: false)
+    def resolve(*keys)
+      keys.inject(self) do |current_registry, key|
+        current_registry.send(:__resolve, key, raise: false) || break
+      end
     end
 
     def to_h
@@ -70,11 +100,11 @@ module NxtRegistry
     end
 
     def [](key)
-      store[transformed_key(key)]
+      resolve!(key)
     end
 
     def []=(key, value)
-      store[transformed_key(key)] = value
+      register(key, value)
     end
 
     def keys
@@ -97,7 +127,7 @@ module NxtRegistry
       store.fetch(transformed_key(key), *args, &block)
     end
 
-    delegate :size, :values, :each, to: :store
+    delegate :size, :values, :each, :freeze, to: :store
 
     def configure(&block)
       define_accessors
@@ -131,7 +161,7 @@ module NxtRegistry
     def __register(key, value, raise: true)
       key = transformed_key(key)
 
-      raise ArgumentError, 'Not allowed to register values in a registry that contains nested registries' unless is_leaf
+      raise ArgumentError, "Not allowed to register values in a registry that contains nested registries" unless is_leaf
       raise KeyError, "Keys are restricted to #{attrs.keys}" if attribute_not_allowed?(key)
 
       on_key_already_registered && on_key_already_registered.call(key) if store[key] && raise
@@ -143,7 +173,7 @@ module NxtRegistry
       key = transformed_key(key)
 
       value = if is_leaf?
-        if store[key]
+        if store.key?(key)
           store.fetch(key)
         else
           if default.is_a?(Blank)
@@ -151,14 +181,13 @@ module NxtRegistry
 
             on_key_not_registered && on_key_not_registered.call(key)
           else
-            value = resolve_default
+            value = resolve_default(key)
             return value unless memoize
 
             store[key] ||= value
           end
         end
       else
-        # Call nested registry builder when we are not a leaf
         store[key] ||= default.call
       end
 
@@ -236,9 +265,9 @@ module NxtRegistry
       attrs.keys.exclude?(transformed_key(key))
     end
 
-    def resolve_default
+    def resolve_default(key)
       if call && default.respond_to?(:call)
-        default.call
+        default.arity > 0 ? default.call(key) : default.call
       else
         default
       end
@@ -272,5 +301,9 @@ module NxtRegistry
     def build_namespace
       parent ? name.to_s.prepend("#{parent.send(:namespace)}.") : name.to_s
     end
+
+    def raise_register_argument_error
+      raise ArgumentError, 'Either provide a key value pair or a block to register'
+    end
   end
 end

data/lib/nxt_registry/{nested_registry_builder.rb → registry_builder.rb}

@@ -1,5 +1,5 @@
 module NxtRegistry
-  class NestedRegistryBuilder < Proc
+  class RegistryBuilder < Proc
     def initialize(&block)
       super(&block)
     end

data/lib/nxt_registry/version.rb

@@ -1,3 +1,3 @@
 module NxtRegistry
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_registry
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Andreas Robecke
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-08-14 00:00:00.000000000 Z
+date: 2020-09-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -108,10 +108,9 @@ files:
 - lib/nxt_registry/attribute.rb
 - lib/nxt_registry/blank.rb
 - lib/nxt_registry/errors.rb
-- lib/nxt_registry/nested_registry_builder.rb
 - lib/nxt_registry/recursive_registry.rb
 - lib/nxt_registry/registry.rb
-- lib/nxt_registry/singleton.rb
+- lib/nxt_registry/registry_builder.rb
 - lib/nxt_registry/version.rb
 - nxt_registry.gemspec
 homepage: https://github.com/nxt-insurance

data/lib/nxt_registry/singleton.rb

@@ -1,17 +0,0 @@
-module NxtRegistry
-  module Singleton
-    def self.extended(subclass)
-      subclass.singleton_class.class_eval do
-        default_name = (subclass.name || 'registry')
-
-        define_method :registry do |name = default_name, **options, &block|
-          @registry ||= NxtRegistry::Registry.new(name, **options, &block)
-        end
-
-        delegate_missing_to :registry
-
-        define_method(:instance) { registry }
-      end
-    end
-  end
-end