nxt_registry 0.3.2 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 07e0435f3a696a2f8c653524b7d69e82445645ea852a3747e66079042844f8c7
-  data.tar.gz: 3377e35d63ec213f0008987aabdd459171c0e6e2a7dca0b2cd9624fc0d6feac3
+  metadata.gz: 37082d21252a90b6499fb9923dc228789b759b50744049510eaf0397a42e1909
+  data.tar.gz: 48ca6d6309ad748386ea97c9ad6d09b7f0badc321c594a5de7f173d5f1d5bfe2
 SHA512:
-  metadata.gz: 488ac1e21b87244d2ba97d5d767fba560bfa011a74cfebd78601d50509ddad7de9cfdb33d4ea6b1857f0c3ef9a7955d82ec40e9f4e6be64487b596341ed02dcd
-  data.tar.gz: 7cad3b456a2075274febf29ff6d25327c713e521a13d541d2640b9acb9344677f3ae89cfd9cdfdf72c3f8c316c4d8f67c4b9718100b74a84dc4c0669e84c1e13
+  metadata.gz: 2df942dfd06fb598b1fd5142023e2809c0ce0ff0f07cf06c2511fa8b3c870a4990a15c2fcb30b269d8d31fc29dd04866f9d812b03c69dcb6723be90a2e80ef4c
+  data.tar.gz: 889b9339a28ce2ce88e162e5d90fc93d3d17f84a697f043cf4ef4c02779856e4476f7a866f66eb891c9d642d2690f4a1173871bb22bf5f3b25ee738849205146

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+# v0.3.5 2020-12-23
+
+- Allow to inherit options in nested registries
+
+# v0.3.5 2020-12-04
+
+- Allow patterns as keys
+
+# 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

data/Gemfile.lock

@@ -1,51 +1,51 @@
 PATH
   remote: .
   specs:
-    nxt_registry (0.3.2)
+    nxt_registry (0.3.7)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.3)
+    activesupport (6.1.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
     coderay (1.1.3)
-    concurrent-ruby (1.1.7)
+    concurrent-ruby (1.1.8)
     diff-lcs (1.4.4)
-    i18n (1.8.5)
+    i18n (1.8.7)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
-    minitest (5.14.2)
+    minitest (5.14.3)
     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.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
       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.1)
       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.1)
     rspec_junit_formatter (0.4.1)
       rspec-core (>= 2, < 4, != 2.12.0)
-    thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
-    zeitwerk (2.4.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
+  x86_64-darwin-19
 
 DEPENDENCIES
   bundler (~> 2.0)
@@ -56,4 +56,4 @@ DEPENDENCIES
   rspec_junit_formatter
 
 BUNDLED WITH
-   2.1.4
+   2.2.4

data/README.md

@@ -27,24 +27,23 @@ Or install it yourself as:
 
 ## Instance Level
 
-To use `NxtRegistry` on an instance level simply include it and build registries like so: 
+If you simply need a single global instance of a registry include `NxtRegistry::Singleton`:    
 
 ```ruby
 class Example
-  include NxtRegistry
+  include NxtRegistry::Singleton
   
-  registry :languages do
+  registry do
     register(:ruby, 'Stone')
     register(:python, 'Snake')
     register(:javascript, 'undefined')
   end
 end
 
-example = Example.new
-example.registry(:languages).resolve(:ruby) # => 'Stone'
+Example.resolve(:ruby) # => 'Stone'
 ```
 
-Alternatively you can also create instances of `NxtRegistry::Registry`
+Alternatively you can simply create instances of `NxtRegistry::Registry`:
 
 ```ruby
 registry = NxtRegistry::Registry.new do
@@ -59,7 +58,7 @@ registry.resolve(:aki) # => 'Aki'
 
 ## Class Level
 
-You can add registries on the class level simply by extending your class with `NxtRegistry`
+You can also add registries on the class level simply by extending your class with `NxtRegistry`
 
 ```ruby
 class OtherExample
@@ -83,6 +82,30 @@ OtherExample.registry(:errors).resolve(KeyError)
 OtherExample.registry(:country_codes).resolve(:germany)
 # => :de
 ```
+
+## Register Patterns
+
+You can also register values with patterns as keys. Non pattern keys are always evaluated first and then patterns 
+will be tried to match by definition sequence.  
+
+```ruby
+class Example
+  extend NxtRegistry
+  
+  registry :status_codes do
+    register(/\A4\d{2}\z/, 'Client errors')
+    register(/\A5.*\z/, 'Server errors')
+    register('422', 'Unprocessable Entity')
+    register(:'503', 'Internal Server Error')
+  end
+end
+
+Example.registry(:status_codes).resolve('503') # => "Internal Server Error"
+Example.registry(:status_codes).resolve(503) # => "Internal Server Error"
+Example.registry(:status_codes).resolve(422) # => "Unprocessable Entity"
+Example.registry(:status_codes).resolve(404) # => "Client Errors"
+```
+
 ### Readers
 
 Access your defined registries with the `registry(:country_code)` method.
@@ -112,6 +135,23 @@ Nested.registry(:developers).resolve(:frontend, :igor)
 # => 'Igor'
 ```
 
+#### Inherit options in nested registries
+
+```ruby
+class Nested
+  extend NxtRegistry
+  
+  registry :developers, default: 'options can be inherited' do
+    register(:frontend, inherit_options: true) do
+      register(:igor, 'Igor')
+      register(:ben, 'Ben')
+    end
+  end
+end
+
+Nested.registry(:developers).resolve(:frontend, :blank)
+# => 'options can be inherited'
+```
 
 ### Defining specific nesting levels of a registry
 
@@ -165,12 +205,21 @@ 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
+### Restrict keys to a certain set
+
+Use `allowed_keys` to restrict which keys can be registered on a specific level.
+
+```ruby
+registry :example, allowed_keys: %w[one two three]
+```
+
+### Require a certain set of keys to be registered
 
-Use `attrs` to restrict which attributes can be registered on a specific level.
+Use `required_keys` to enforce a certain set of keys to be registered on a specific level. This is especially helpful
+if you use registries in multiple places and you want to ensure they all register the same set of keys. 
 
 ```ruby
-registry :example, attrs: %w[one two three]
+registry :example, required_keys: %w[one two three]
 ```
 
 ### Default values

data/lib/nxt_registry.rb

@@ -1,11 +1,12 @@
+require 'active_support'
 require 'active_support/core_ext'
 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)
@@ -19,17 +20,17 @@ module NxtRegistry
   private
 
   def build_registry(registry_class, name, **options, &config)
-    if registries.key?(name)
-      registry = registries.fetch(name)
+    registry = registries.resolve(name)
+
+    if registry.present?
       if registry.configured
-        registry
+        return registry
       else
         raise_unconfigured_registry_accessed(name)
       end
     else
       registry = registry_class.new(name, **options, &config)
-      registries[name] ||= registry
-      registry
+      registries.register(name, registry)
     end
   end
 
@@ -38,6 +39,6 @@ module NxtRegistry
   end
 
   def registries
-    @registries ||= {}
+    @registries ||= Registry.new(:registries)
   end
 end

data/lib/nxt_registry/errors.rb

@@ -2,5 +2,7 @@ module NxtRegistry
   module Errors
     KeyAlreadyRegisteredError = Class.new(KeyError)
     KeyNotRegisteredError = Class.new(KeyError)
+    RequiredKeyMissing = Class.new(KeyError)
+    KeyNotAllowed = Class.new(KeyError)
   end
 end

data/lib/nxt_registry/registry.rb

@@ -8,10 +8,10 @@ module NxtRegistry
       @namespace = build_namespace
       @config = config
       @store = {}
-      @attrs = nil
       @configured = false
+      @patterns = []
+      @config = config
 
-      setup_defaults(options)
       configure(&config)
     end
 
@@ -38,27 +38,33 @@ module NxtRegistry
     end
 
     def registry(name, **options, &config)
-      opts = options.merge(parent: self)
+      opts = conditionally_inherit_options(options)
       register(name, Registry.new(name, **opts, &config))
     end
 
     def registry!(name, **options, &config)
-      opts = options.merge(parent: self)
+      opts = conditionally_inherit_options(options)
       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]
+    def required_keys(*keys)
+      @required_keys ||= []
+      return @required_keys if keys.empty?
+
+      @required_keys += keys.map { |key| transformed_key(key) }
+    end
+
+    def allowed_keys(*keys)
+      @allowed_keys ||= []
+      return @allowed_keys if keys.empty?
 
-      attrs[key] = Attribute.new(key, self)
+      @allowed_keys += keys.map { |key| transformed_key(key) }
     end
 
-    def attrs(*args)
-      @attrs ||= {}
-      return @attrs unless args.any?
+    alias attrs allowed_keys # @deprecated
 
-      args.each { |name| attr(name) }
+    def attr(key)
+      allowed_keys(key) # @deprecated
     end
 
     def register(key = Blank.new, value = Blank.new, **options, &block)
@@ -126,15 +132,18 @@ module NxtRegistry
     end
 
     def fetch(key, *args, &block)
-      store.fetch(transformed_key(key), *args, &block)
+      key = matching_key(key)
+      store.fetch(key, *args, &block)
     end
 
     delegate :size, :values, :each, :freeze, to: :store
 
     def configure(&block)
+      setup_defaults(options)
       define_accessors
       define_interface
-      attrs(*Array(options.fetch(:attrs, [])))
+      allowed_keys(*Array(options.fetch(:allowed_keys, [])))
+      required_keys(*Array(options.fetch(:required_keys, [])))
 
       if block.present?
         if block.arity == 1
@@ -144,6 +153,7 @@ module NxtRegistry
         end
       end
 
+      validate_required_keys_given
       self.configured = true
     end
 
@@ -151,22 +161,40 @@ module NxtRegistry
       "Registry[#{name}] -> #{store.to_s}"
     end
 
-    alias_method :inspect, :to_s
+    alias inspect to_s
 
     private
 
-    attr_reader :namespace, :parent, :config, :store, :options, :accessor
+    attr_reader :namespace, :parent, :config, :store, :options, :accessor, :patterns
     attr_accessor :is_leaf, :interface_defined
 
+    def conditionally_inherit_options(opts)
+      base = opts.delete(:inherit_options) ? options : {}
+      base.merge(opts).merge(parent: self)
+    end
+
+    def validate_required_keys_given
+      required_keys.each do |key|
+        next if store.key?(key)
+
+        raise Errors::RequiredKeyMissing, "Required key '#{key}' missing in #{self}"
+      end
+    end
+
     def is_leaf?
       @is_leaf
     end
 
     def __register(key, value, raise_on_key_already_registered: true)
-      key = transformed_key(key)
+      key = if key.is_a?(Regexp)
+        patterns << key
+        key
+      else
+        transformed_key(key)
+      end
 
       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)
+      raise KeyError, "Keys are restricted to #{allowed_keys}" if key_not_allowed?(key)
 
       on_key_already_registered && on_key_already_registered.call(key) if store[key] && raise_on_key_already_registered
 
@@ -179,6 +207,8 @@ module NxtRegistry
       value = if is_leaf?
         if store.key?(key)
           store.fetch(key)
+        elsif (pattern = matching_pattern(key))
+          store.fetch(pattern)
         else
           if is_a_blank?(default)
             return unless raise_on_key_not_registered
@@ -195,11 +225,7 @@ module NxtRegistry
         store[key] ||= default.call
       end
 
-      value = if value.respond_to?(:call) && call && !value.is_a?(NxtRegistry::Registry)
-        value.call(*[value].take(value.arity))
-      else
-        value
-      end
+      value = call_or_value(value, key)
 
       if resolver
         resolver.call(value)
@@ -208,14 +234,35 @@ module NxtRegistry
       end
     end
 
+    def matching_key(key)
+      key = transformed_key(key)
+      # if key is present it always wins over patterns
+      return key if store.key?(key)
+
+      matching_pattern(key) || key
+    end
+
+    def call_or_value(value, key)
+      return value unless call
+      return value if value.is_a?(NxtRegistry::Registry)
+      return value unless value.respond_to?(:call)
+
+      args = [key, value]
+      value.call(*args.take(value.arity))
+    end
+
+    def matching_pattern(key)
+      patterns.find { |pattern| key.match?(pattern) }
+    end
+
     def define_interface
       return if interface_defined
 
-      raise_invalid_accessor_name(accessor) if respond_to?(accessor)
+      raise_invalid_accessor_name(accessor) if respond_to?(accessor.to_s)
       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|
+      define_singleton_method accessor.to_s do |key = Blank.new, value = Blank.new|
         return self if is_a_blank?(key)
 
         key = transformed_key(key)
@@ -247,7 +294,7 @@ module NxtRegistry
       @memoize = options.fetch(:memoize) { true }
       @call = options.fetch(:call) { true }
       @resolver = options.fetch(:resolver, false)
-      @transform_keys = options.fetch(:transform_keys) { ->(key) { key.to_s } }
+      @transform_keys = options.fetch(:transform_keys) { ->(key) { key.is_a?(Regexp) ? 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) } }
@@ -272,10 +319,10 @@ module NxtRegistry
       end
     end
 
-    def attribute_not_allowed?(key)
-      return if attrs.empty?
+    def key_not_allowed?(key)
+      return if allowed_keys.empty?
 
-      attrs.keys.exclude?(transformed_key(key))
+      allowed_keys.exclude?(transformed_key(key))
     end
 
     def resolve_default(key)
@@ -305,12 +352,6 @@ module NxtRegistry
       end
     end
 
-    def initialize_copy(original)
-      super
-      @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

data/lib/nxt_registry/singleton.rb

@@ -0,0 +1,15 @@
+module NxtRegistry
+  module Singleton
+    include NxtRegistry
+
+    def self.included(base)
+      base.extend(self)
+    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.3.2"
+  VERSION = '0.3.7'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_registry
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.7
 platform: ruby
 authors:
 - Andreas Robecke
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-30 00:00:00.000000000 Z
+date: 2021-01-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -106,12 +106,12 @@ files:
 - bin/console
 - bin/setup
 - lib/nxt_registry.rb
-- lib/nxt_registry/attribute.rb
 - lib/nxt_registry/blank.rb
 - lib/nxt_registry/errors.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
 homepage: https://github.com/nxt-insurance

data/lib/nxt_registry/attribute.rb

@@ -1,17 +0,0 @@
-module NxtRegistry
-  class Attribute
-    def initialize(name, registry, **options)
-      @name = name
-      @registry = registry
-      @namespace = [name, registry.send(:namespace)].join('.')
-    end
-
-    def eql?(other)
-      { name => registry.object_id } == { other.send(:name) => other.send(:registry).object_id }
-    end
-
-    private
-
-    attr_reader :name, :registry
-  end
-end