nxt_registry 0.1.5 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7580358cb0ea45fffde45350fe3162957158c25a41cabd7a3faeba4e3901515
-  data.tar.gz: 0dd9ff5a3904ca34ab631d405a29fcd0cf6bed1d62f37fff01f425e6e44b5c45
+  metadata.gz: 07e0435f3a696a2f8c653524b7d69e82445645ea852a3747e66079042844f8c7
+  data.tar.gz: 3377e35d63ec213f0008987aabdd459171c0e6e2a7dca0b2cd9624fc0d6feac3
 SHA512:
-  metadata.gz: a3aa0bec05c05bc39f6db505ef90b29eadd33e750138a00fb21ac21464683de08034ee528343ea3dd775d230d6a7db3b71ea21c21d1e60286aa72c06ac420167
-  data.tar.gz: fe9f8f96fd76c5810638d33a73b4f0052d1b1e5e533d5bb506120a8abe442c466b16ba766d7788c3d2887f4f6fbe9b34a97cbec27a40b96c1f06bdb6f4c0d5bb
+  metadata.gz: 488ac1e21b87244d2ba97d5d767fba560bfa011a74cfebd78601d50509ddad7de9cfdb33d4ea6b1857f0c3ef9a7955d82ec40e9f4e6be64487b596341ed02dcd
+  data.tar.gz: 7cad3b456a2075274febf29ff6d25327c713e521a13d541d2640b9acb9344677f3ae89cfd9cdfdf72c3f8c316c4d8f67c4b9718100b74a84dc4c0669e84c1e13

data/.circleci/config.yml

@@ -0,0 +1,56 @@
+# Ruby CircleCI 2.0 configuration file
+#
+# Check https://circleci.com/docs/2.0/language-ruby/ for more details
+#
+version: 2
+jobs:
+  build:
+    docker:
+      # specify the version you desire here
+      - image: circleci/ruby:2.6.5-node
+    environment:
+      BUNDLER_VERSION: 2.1.4
+
+    working_directory: ~/repo
+
+    steps:
+      - checkout
+
+      # Download and cache dependencies
+      - restore_cache:
+          keys:
+            - v1-dependencies-{{ checksum "Gemfile.lock" }}
+            
+      - run: gem install bundler --version $BUNDLER_VERSION
+
+      - run:
+          name: install dependencies
+          command: |
+            bundle install --jobs=4 --retry=3 --path vendor/bundle
+
+      - save_cache:
+          paths:
+            - ./vendor/bundle
+          key: v1-dependencies-{{ checksum "Gemfile.lock" }}
+
+      # run tests!
+      - run:
+          name: run tests
+          command: |
+            mkdir /tmp/test-results
+            TEST_FILES="$(circleci tests glob "spec/**/*_spec.rb" | \
+              circleci tests split --split-by=timings)"
+
+            bundle exec rspec \
+              --format progress \
+              --format RspecJunitFormatter \
+              --out /tmp/test-results/rspec.xml \
+              --format progress \
+              $TEST_FILES
+
+      # collect reports
+      - store_test_results:
+          path: /tmp/test-results
+      - store_artifacts:
+          path: /tmp/test-results
+          destination: test-results

data/.editorconfig

@@ -0,0 +1,15 @@
+# EditorConfig is awesome: http://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+# Unix-style newlines with a newline ending every file
+[*]
+end_of_line = lf
+insert_final_newline = true
+charset = utf-8
+
+[*.{rb,yml,json,rake}]
+indent_style = space
+indent_size = 2
+trim_trailing_whitespace = true

data/CHANGELOG.md

@@ -0,0 +1,41 @@
+# 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
+ 
+- Fixed Registry#fetch to raise key error in case of missing key
+
+[Compare v0.2.0...v0.2.1](https://github.com/nxt-insurance/nxt_registry/compare/v0.2.0...v0.2.1)
+
+
+# v0.2.0 2020-07-24
+
+### Added
+
+- [internal] Added NxtRegistry::Singleton
+- Added NxtRegistry::Singleton interface
+- Make name optional and have object_id.to_s as default name 
+- Fix readme
+
+[Compare v0.1.5...v0.2.0](https://github.com/nxt-insurance/nxt_registry/compare/v0.1.5...v0.2.0)

data/Gemfile

@@ -2,3 +2,7 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in nxt_registry.gemspec
 gemspec
+
+group :test do
+  gem 'rspec_junit_formatter' # for CircleCI
+end

data/Gemfile.lock

@@ -1,46 +1,48 @@
 PATH
   remote: .
   specs:
-    nxt_registry (0.1.5)
+    nxt_registry (0.3.2)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.2.1)
+    activesupport (6.0.3.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-      zeitwerk (~> 2.2)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.6)
-    diff-lcs (1.3)
-    i18n (1.8.2)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.4.4)
+    i18n (1.8.5)
       concurrent-ruby (~> 1.0)
-    method_source (0.9.2)
-    minitest (5.14.0)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
+    method_source (1.0.0)
+    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.1)
-      rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
       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)
+    rspec-support (3.9.3)
+    rspec_junit_formatter (0.4.1)
+      rspec-core (>= 2, < 4, != 2.12.0)
     thread_safe (0.3.6)
-    tzinfo (1.2.6)
+    tzinfo (1.2.7)
       thread_safe (~> 0.1)
-    zeitwerk (2.2.2)
+    zeitwerk (2.4.0)
 
 PLATFORMS
   ruby
@@ -51,6 +53,7 @@ DEPENDENCIES
   pry
   rake (~> 12)
   rspec (~> 3.0)
+  rspec_junit_formatter
 
 BUNDLED WITH
    2.1.4

data/README.md

@@ -1,7 +1,9 @@
+[![CircleCI](https://circleci.com/gh/nxt-insurance/nxt_registry.svg?style=svg)](https://circleci.com/gh/nxt-insurance/nxt_registry)
+
 # 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
 
@@ -21,80 +23,148 @@ Or install it yourself as:
 
 ## Usage
 
+### 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'])  
+example.registry(:languages).resolve(:ruby) # => 'Stone'
+```
 
-# 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...
+Alternatively you can also create instances of `NxtRegistry::Registry`
 
-# 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) # []
+```ruby
+registry = NxtRegistry::Registry.new do
+  register(:andy, 'Andy')
+  register(:anthony, 'Anthony')
+  register(:aki, 'Aki')
+end
 
-# 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']
+registry.resolve(:aki) # => 'Aki'
 
 ```
 
+## Class Level
+
+You can add registries on the class level simply by extending your class with `NxtRegistry`
 
 ```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 
+ 
+  registry(:errors) do
     register(KeyError, ->(error) { puts 'KeyError handler' } )
     register(ArgumentError, ->(error) { puts 'ArgumentError handler' } )
   end
+
+  registry(:country_codes) do
+    register(:germany, :de)
+    register(:england, :uk)
+    register(:france, :fr)
+  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)
+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 Nested
+  extend NxtRegistry
+
+  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
+
+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.
@@ -113,7 +183,7 @@ 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. 
+When you register a block value that can be called, it 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
@@ -124,7 +194,7 @@ end
 
 ### Memoize
 
-Values are memoized per default. Switch it off with `default false`
+Values are memoized per default. Switch it off with `memoize: false`
 
 ```ruby
 registry :example, memoize: false do
@@ -141,7 +211,8 @@ registry.resolve(:one)
 
 ### Resolver
 
-You can register a resolver block if you want to lay hands on your values after they have been resolved.
+You can register a resolver block if you want to lay hands on your values after they have been resolved. 
+A resolver can be anything that implements `:call` to which the value is passed.  
 
 ```ruby
 registry :example do
@@ -155,9 +226,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
@@ -172,7 +244,7 @@ registry.resolve('BOMBSHELL')
 ### 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`
+by providing blocks or a handler responding to :call for `on_key_already_registered` and `on_key_already_registered`
 
 ## Development
 

data/lib/nxt_registry.rb

@@ -1,18 +1,43 @@
 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/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'
 
 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)
+    if registries.key?(name)
+      registry = registries.fetch(name)
+      if registry.configured
+        registry
+      else
+        raise_unconfigured_registry_accessed(name)
+      end
+    else
+      registry = registry_class.new(name, **options, &config)
+      registries[name] ||= registry
+      registry
+    end
+  end
+
+  def raise_unconfigured_registry_accessed(name)
+    raise ArgumentError, "The registry #{name} must be configured before accessed!"
+  end
+
+  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

@@ -1,40 +1,52 @@
 module NxtRegistry
   class Registry
-    def initialize(name, **options, &config)
+    def initialize(name = object_id.to_s, **options, &config)
+      @options = options
       @name = name
       @parent = options[:parent]
       @is_leaf = true
-      @namespace = parent ? name.to_s.prepend("#{parent.send(:namespace)}.") : name.to_s
+      @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)
-        raise ArgumentError, "Multiple nestings on the same level"
+      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"
+        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
@@ -93,11 +125,11 @@ module NxtRegistry
       store.exclude?(transformed_key(key))
     end
 
-    def fetch(key, **opts, &block)
-      store.fetch(transformed_key(key), **opts, &block)
+    def fetch(key, *args, &block)
+      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,44 +155,43 @@ 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 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
 
@@ -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) } }
@@ -215,10 +257,9 @@ module NxtRegistry
     def define_accessors
       %w[default memoize call resolver transform_keys on_key_already_registered on_key_not_registered].each do |attribute|
         define_singleton_method attribute do |value = Blank.new, &block|
-          # TODO: Allowing a block does not make sense for memoize and call?!
           value = block if block
 
-          if value.is_a?(Blank)
+          if is_a_blank?(value)
             instance_variable_get("@#{attribute}")
           else
             instance_variable_set("@#{attribute}", value)
@@ -237,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
@@ -256,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
@@ -269,5 +310,21 @@ module NxtRegistry
       @store = original.send(:store).deep_dup
       @options = original.send(:options).deep_dup
     end
+
+    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/version.rb

@@ -1,3 +1,3 @@
 module NxtRegistry
-  VERSION = "0.1.5"
+  VERSION = "0.3.2"
 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.1.5
+  version: 0.3.2
 platform: ruby
 authors:
 - Andreas Robecke
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-03-02 00:00:00.000000000 Z
+date: 2020-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -85,15 +85,19 @@ dependencies:
         version: '0'
 description: 
 email:
-- a.robecke@getsafe.de
+- a.robecke@hellogetsafe.com
+- andreas@robecke.de
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".circleci/config.yml"
+- ".editorconfig"
 - ".gitignore"
 - ".rakeTasks"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -105,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/version.rb
 - nxt_registry.gemspec
 homepage: https://github.com/nxt-insurance