nxt_registry 0.2.1 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6851c2c3d6dde7438aa6abe438153d4126ea962f948d472a37d8b958830390f3
-  data.tar.gz: '02158d50dd9af0686bd4427e1c41853dca588e686b9a02381263c94700093398'
+  metadata.gz: b3c4dec7379f1076565a8fa2306e9aba2bfbd12f1191648929635db61a7b4a94
+  data.tar.gz: '081a471bb51c5e53089ee8341f439b8b70bdb22bb45c24add42673210ecacd0c'
 SHA512:
-  metadata.gz: 04c65be146020a7e3c1e1fa6587cdb9efb0c4b2ab6d76741855fe99a0246e4a5ace755c3184678164f388d41a45ddc6a03c39298c0038ecf13e454f77a5deb74
-  data.tar.gz: f992919cf0d07da41e411b7dff32410678b664f4a12a47e350e0d51e239c6864eaeb549aca4518eae1f122640b99274897e6bc4b39bb6889634e6a32ee137931
+  metadata.gz: 7913f84e7bfea3f58efd487eb9bbdc34c988fb3297101aa52525e530c8a6bec5b2d5bc6dfc81bd188f4145c99a74dbbb65b556b6acf847b16df529a65b612999
+  data.tar.gz: 59fe97c3fe3bbc653bd63f6e7bd835d08189136fc328d9ce0fa62e8199dcc311fa152d2d0ebedb1b7a580b3ef20a6253dfbb02c605a700f88a42076bd57935be

data/CHANGELOG.md

@@ -1,3 +1,34 @@
+# v0.3.4 2020-12-04
+
+- Bring back Singleton
+- Fix mistakes in readme
+
+# v0.3.3 2020-11-24
+
+- Fix: Pass key to resolver instead of value 
+
+# v0.3.2 2020-09-29
+
+- Fix interface definition
+
+# v0.3.1 2020-09-23
+
+- Allow to define custom accessors for registries
+
+# 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.4)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.2)
+    activesupport (6.0.3.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -19,30 +19,30 @@ 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)
     rake (12.3.3)
-    rspec (3.9.0)
-      rspec-core (~> 3.9.0)
-      rspec-expectations (~> 3.9.0)
-      rspec-mocks (~> 3.9.0)
-    rspec-core (3.9.2)
-      rspec-support (~> 3.9.3)
-    rspec-expectations (3.9.2)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-mocks (3.9.1)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.9.0)
-    rspec-support (3.9.3)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
     rspec_junit_formatter (0.4.1)
       rspec-core (>= 2, < 4, != 2.12.0)
     thread_safe (0.3.6)
-    tzinfo (1.2.7)
+    tzinfo (1.2.8)
       thread_safe (~> 0.1)
-    zeitwerk (2.4.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby

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,27 @@ Or install it yourself as:
 
 ## Usage
 
-### Instance Level
+### Simple use case
+
+## Instance Level
+
+If you simply need a single global instance of a registry include `NxtRegistry::Singleton`:    
 
 ```ruby
 class Example
-  include NxtRegistry
+  include NxtRegistry::Singleton
   
-  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 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.resolve(:ruby) # => 'Stone'
 ```
 
-Alternatively you can create an instance of NxtRegistry::Registry.new('name', **options, &config)
+Alternatively you can simply create instances of `NxtRegistry::Registry`:
 
 ```ruby
 registry = NxtRegistry::Registry.new do
@@ -90,52 +56,114 @@ registry.resolve(:aki) # => 'Aki'
 
 ```
 
-### Class Level
+## Class Level
+
+You can also add 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
+
+# On every upper level every resolve returns a registry 
+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] -> {}
+
+# Register a value on the bottom level
+Layer.registry(:from).resolve(:munich, :amsterdam).register(:train, -> { 'train' })
+# Resolve the complete path 
+Layer.registry(:from).resolve(:munich, :amsterdam, :train) #  => 'train'
+``` 
+
+For registries with multiple levels the normal syntax for registering and resolving becomes quite weird and unreadable. This is why
+every registry can be accessed through it's name or a custom accessor. The above example then can be simplified as follows.
+
+```ruby
+class Layer
+  extend NxtRegistry
+  
+  registry :path, accessor: :from do # registry named path, can be accessed with .from(...)
+    level :to do
+      level :via
+    end  
+  end
+end
+
+# Register a value
+Layer.registry(:path).from(:munich).to(:amsterdam).via(:train, -> { 'train' })
+# Resolve the complete path
+Layer.registry(:path).from(:munich).to(:amsterdam).via(:train) #  => 'train'
 ```
 
+*Note that this feature is also available for registries with a single level only.*
+
 ### Restrict attributes to a certain set
 
 Use `attrs` to restrict which attributes can be registered on a specific level.
@@ -197,9 +225,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

@@ -1,19 +1,44 @@
 require 'active_support/core_ext'
-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"
-require "nxt_registry/recursive_registry"
-require "nxt_registry/singleton"
+require 'nxt_registry/version'
+require 'nxt_registry/blank'
+require 'nxt_registry/attribute'
+require 'nxt_registry/errors'
+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)
+    build_registry(Registry, name, **options, &config)
   end
 
   def recursive_registry(name, **options, &config)
-    RecursiveRegistry.new(name, **options, &config)
+    build_registry(RecursiveRegistry, name, **options, &config)
+  end
+
+  private
+
+  def build_registry(registry_class, name, **options, &config)
+    registry = registries.resolve(name)
+
+    if registry.present?
+      if registry.configured
+        return registry
+      else
+        raise_unconfigured_registry_accessed(name)
+      end
+    else
+      registry = registry_class.new(name, **options, &config)
+      registries.register(name, registry)
+    end
+  end
+
+  def raise_unconfigured_registry_accessed(name)
+    raise ArgumentError, "The registry #{name} must be configured before accessed!"
+  end
+
+  def registries
+    @registries ||= Registry.new(: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

@@ -1,40 +1,52 @@
 module NxtRegistry
   class Registry
     def initialize(name = object_id.to_s, **options, &config)
+      @options = options
       @name = name
       @parent = options[:parent]
       @is_leaf = true
       @namespace = build_namespace
       @config = config
-      @options = options
       @store = {}
       @attrs = nil
+      @configured = false
 
       setup_defaults(options)
       configure(&config)
     end
 
     attr_reader :name
+    attr_accessor :configured
 
-    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)
+      if is_a_blank?(default)
         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)
+      opts = options.merge(parent: self)
+      register(name, Registry.new(name, **opts, &config))
+    end
+
+    def registry!(name, **options, &config)
+      opts = options.merge(parent: self)
+      register!(name, Registry.new(name, **opts, &config))
+    end
+
     def attr(name)
       key = transformed_key(name)
       raise KeyError, "Attribute #{key} already registered in #{namespace}" if attrs[key]
@@ -49,20 +61,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 is_a_blank?(value)
+          registry(key, **options, &block)
+        else
+          raise_register_argument_error
+        end
+      else
+        __register(key, value, raise_on_key_already_registered: 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 is_a_blank?(value)
+          registry!(key, **options, &block)
+        else
+          raise_register_argument_error
+        end
+      else
+        __register(key, value, raise_on_key_already_registered: 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_on_key_not_registered: 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_on_key_not_registered: false) || break
+      end
     end
 
     def to_h
@@ -70,11 +102,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 +129,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
@@ -111,6 +143,8 @@ module NxtRegistry
           instance_exec(&block)
         end
       end
+
+      self.configured = true
     end
 
     def to_s
@@ -121,49 +155,48 @@ module NxtRegistry
 
     private
 
-    attr_reader :namespace, :parent, :config, :store, :options
-    attr_accessor :is_leaf
+    attr_reader :namespace, :parent, :config, :store, :options, :accessor
+    attr_accessor :is_leaf, :interface_defined
 
     def is_leaf?
       @is_leaf
     end
 
-    def __register(key, value, raise: true)
+    def __register(key, value, raise_on_key_already_registered: 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
+      on_key_already_registered && on_key_already_registered.call(key) if store[key] && raise_on_key_already_registered
 
       store[key] = value
     end
 
-    def __resolve(key, raise: true)
+    def __resolve(key, raise_on_key_not_registered: true)
       key = transformed_key(key)
 
       value = if is_leaf?
-        if store[key]
+        if store.key?(key)
           store.fetch(key)
         else
-          if default.is_a?(Blank)
-            return unless raise
+          if is_a_blank?(default)
+            return unless raise_on_key_not_registered
 
             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
 
       value = if value.respond_to?(:call) && call && !value.is_a?(NxtRegistry::Registry)
-        value.call(*[value].take(value.arity))
+        value.call(*[key].take(value.arity))
       else
         value
       end
@@ -176,29 +209,37 @@ module NxtRegistry
     end
 
     def define_interface
-      define_singleton_method name do |key = Blank.new, value = Blank.new|
-        return self if key.is_a?(Blank)
+      return if interface_defined
+
+      raise_invalid_accessor_name(accessor) if respond_to?(accessor)
+      accessor_with_bang = "#{accessor}!"
+      raise_invalid_accessor_name(accessor_with_bang) if respond_to?(accessor_with_bang)
+
+      define_singleton_method accessor do |key = Blank.new, value = Blank.new|
+        return self if is_a_blank?(key)
 
         key = transformed_key(key)
 
-        if value.is_a?(Blank)
+        if is_a_blank?(value)
           resolve(key)
         else
           register(key, value)
         end
       end
 
-      define_singleton_method "#{name}!" do |key = Blank.new, value = Blank.new|
-        return self if key.is_a?(Blank)
+      define_singleton_method accessor_with_bang do |key = Blank.new, value = Blank.new|
+        return self if is_a_blank?(key)
 
         key = transformed_key(key)
 
-        if value.is_a?(Blank)
+        if is_a_blank?(value)
           resolve!(key)
         else
           register!(key, value)
         end
       end
+
+      self.interface_defined = true
     end
 
     def setup_defaults(options)
@@ -207,6 +248,7 @@ module NxtRegistry
       @call = options.fetch(:call) { true }
       @resolver = options.fetch(:resolver, false)
       @transform_keys = options.fetch(:transform_keys) { ->(key) { key.to_s } }
+      @accessor = options.fetch(:accessor) { name }
 
       @on_key_already_registered = options.fetch(:on_key_already_registered) { ->(key) { raise_key_already_registered_error(key) } }
       @on_key_not_registered = options.fetch(:on_key_not_registered) { ->(key) { raise_key_not_registered_error(key) } }
@@ -217,7 +259,7 @@ module NxtRegistry
         define_singleton_method attribute do |value = Blank.new, &block|
           value = block if block
 
-          if value.is_a?(Blank)
+          if is_a_blank?(value)
             instance_variable_get("@#{attribute}")
           else
             instance_variable_set("@#{attribute}", value)
@@ -236,9 +278,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
@@ -255,7 +297,7 @@ module NxtRegistry
     def transformed_key(key)
       @transformed_key ||= {}
       @transformed_key[key] ||= begin
-        if transform_keys && !key.is_a?(Blank)
+        if transform_keys && !is_a_blank?(key)
           transform_keys.call(key)
         else
           key
@@ -272,5 +314,17 @@ 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
+
+    def is_a_blank?(value)
+      value.is_a?(Blank)
+    end
+
+    def raise_invalid_accessor_name(name)
+      raise ArgumentError, "#{self} already implements a method named: #{name}. Please choose a different accessor name"
+    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/singleton.rb

@@ -1,17 +1,15 @@
 module NxtRegistry
   module Singleton
-    def self.extended(subclass)
-      subclass.singleton_class.class_eval do
-        default_name = (subclass.name || 'registry')
+    include NxtRegistry
 
-        define_method :registry do |name = default_name, **options, &block|
-          @registry ||= NxtRegistry::Registry.new(name, **options, &block)
-        end
-
-        delegate_missing_to :registry
+    def self.included(base)
+      base.extend(self)
+    end
 
-        define_method(:instance) { registry }
-      end
+    def registry(type = Registry, **options, &config)
+      @registry ||= build_registry(type, self.class.name, **options, &config)
     end
+
+    delegate_missing_to :registry
   end
 end

data/lib/nxt_registry/version.rb

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

data/nxt_registry.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |spec|
   spec.name          = "nxt_registry"
   spec.version       = NxtRegistry::VERSION
   spec.authors       = ["Andreas Robecke", "Nils Sommer", "Raphael Kallensee", "Lütfi Demirci"]
-  spec.email         = ["a.robecke@getsafe.de"]
+  spec.email         = ['a.robecke@hellogetsafe.com', 'andreas@robecke.de']
 
   spec.summary       = %q{nxt_registry is a simple implementation of the container pattern}
   spec.homepage      = "https://github.com/nxt-insurance"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_registry
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.4
 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-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -85,7 +85,8 @@ dependencies:
         version: '0'
 description: 
 email:
-- a.robecke@getsafe.de
+- a.robecke@hellogetsafe.com
+- andreas@robecke.de
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -108,9 +109,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/registry_builder.rb
 - lib/nxt_registry/singleton.rb
 - lib/nxt_registry/version.rb
 - nxt_registry.gemspec