nxt_registry 0.3.4 → 0.3.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b3c4dec7379f1076565a8fa2306e9aba2bfbd12f1191648929635db61a7b4a94
-  data.tar.gz: '081a471bb51c5e53089ee8341f439b8b70bdb22bb45c24add42673210ecacd0c'
+  metadata.gz: 3263cdc8c48171dfc6ecfe2bbe2eedb97d72e0ab8d367945ed04ec2480b2caa0
+  data.tar.gz: a7f48fa6c75182d1489cdcb28f19127892bd63b3de655e3e0db40e1b81204031
 SHA512:
-  metadata.gz: 7913f84e7bfea3f58efd487eb9bbdc34c988fb3297101aa52525e530c8a6bec5b2d5bc6dfc81bd188f4145c99a74dbbb65b556b6acf847b16df529a65b612999
-  data.tar.gz: 59fe97c3fe3bbc653bd63f6e7bd835d08189136fc328d9ce0fa62e8199dcc311fa152d2d0ebedb1b7a580b3ef20a6253dfbb02c605a700f88a42076bd57935be
+  metadata.gz: 672c5855be89793548452a157d5c196b7a79271269ff43d056b18a2711b2c6ce7fb7cccca11892e05161fcf682eed15b55d7194bc27968d0d99b1066ae8b5ecc
+  data.tar.gz: ae6e5c77734afc4d9f732e7179fa62ef1f4b96c5a1278632cb91ce79ea33b803bd22b83f4084711d674698b786f6749033349ed541b152c05b43532936d53df3

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+# v0.3.10 2021-03-30
+- Do not synchronize resolve with mutex
+
+# v0.3.9 2021-03-10
+
+- Synchronize access with Mutex
+- Add key_resolver
+- Fix: Inherit options set through accessors
+
+# 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

data/Gemfile.lock

@@ -1,26 +1,26 @@
 PATH
   remote: .
   specs:
-    nxt_registry (0.3.4)
+    nxt_registry (0.3.10)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.4)
+    activesupport (6.1.3.2)
       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.10)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
-    minitest (5.14.2)
-    pry (0.13.1)
+    minitest (5.14.4)
+    pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
     rake (12.3.3)
@@ -28,24 +28,24 @@ GEM
       rspec-core (~> 3.10.0)
       rspec-expectations (~> 3.10.0)
       rspec-mocks (~> 3.10.0)
-    rspec-core (3.10.0)
+    rspec-core (3.10.1)
       rspec-support (~> 3.10.0)
-    rspec-expectations (3.10.0)
+    rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
-    rspec-mocks (3.10.0)
+    rspec-mocks (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.10.0)
-    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.8)
-      thread_safe (~> 0.1)
+    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

@@ -2,8 +2,7 @@
 
 # NxtRegistry
 
-`NxtRegistry` is a simple implementation of the container pattern. It allows you to register and resolve values in nested 
-structures.
+`NxtRegistry` is a simple container that allows you to register and resolve values in nested structures.
 
 ## Installation
 
@@ -82,6 +81,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.
@@ -111,6 +134,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
 
@@ -164,12 +204,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 `attrs` to restrict which attributes can be registered on a specific level.
+Use `allowed_keys` to restrict which keys can be registered on a specific level.
 
 ```ruby
-registry :example, attrs: %w[one two three]
+registry :example, allowed_keys: %w[one two three]
+```
+
+### Require a certain set of keys to be registered
+
+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, required_keys: %w[one two three]
 ```
 
 ### Default values
@@ -208,19 +257,21 @@ registry.resolve(:one)
 # => 2020-01-02 23:56:18 +0100
 ```
 
-### Resolver
+### Resolve callbacks
 
-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.  
+You can hook into the before and after resolver callbacks in case you need to lay hands on your values
+before and / or after resolving. A callback can be anything that implements `:call` to which the value is passed.  
 
 ```ruby
 registry :example do
-  resolver ->(value) { value * 2 }
-  register(:one, 1)
+  key_resolver ->(key) { key.strip }
+  resolver ->(value) { value.upcase }
+  
+  register(:input, 'output')
 end
 
-registry.resolve(:one)
-# => 2
+registry.resolve('  input   ')
+# => 'OUTPUT'
 ```
 
 ### Transform keys

data/lib/nxt_registry.rb

@@ -1,7 +1,7 @@
+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'

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,14 +8,15 @@ module NxtRegistry
       @namespace = build_namespace
       @config = config
       @store = {}
-      @attrs = nil
       @configured = false
+      @patterns = []
+      @config = config
+      @mutex = Mutex.new
 
-      setup_defaults(options)
       configure(&config)
     end
 
-    attr_reader :name
+    attr_reader :name, :mutex
     attr_accessor :configured
 
     def level(name, **options, &config)
@@ -38,27 +39,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 +133,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 +154,7 @@ module NxtRegistry
         end
       end
 
+      validate_required_keys_given
       self.configured = true
     end
 
@@ -151,34 +162,59 @@ 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)
+      mutex.synchronize do
+        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 ArgumentError, "Not allowed to register values in a registry that contains nested registries" unless is_leaf
+        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
+        on_key_already_registered && on_key_already_registered.call(key) if store[key] && raise_on_key_already_registered
 
-      store[key] = value
+        store[key] = value
+      end
     end
 
     def __resolve(key, raise_on_key_not_registered: true)
+
       key = transformed_key(key)
 
       value = if is_leaf?
-        if store.key?(key)
-          store.fetch(key)
+        resolved_key = key_resolver.call(key)
+
+        if store.key?(resolved_key)
+          store.fetch(resolved_key)
+        elsif (pattern = matching_pattern(resolved_key))
+          store.fetch(pattern)
         else
           if is_a_blank?(default)
             return unless raise_on_key_not_registered
@@ -195,27 +231,40 @@ module NxtRegistry
         store[key] ||= default.call
       end
 
-      value = if value.respond_to?(:call) && call && !value.is_a?(NxtRegistry::Registry)
-        value.call(*[key].take(value.arity))
-      else
-        value
-      end
+      value = call_or_value(value, key)
 
-      if resolver
-        resolver.call(value)
-      else
-        value
-      end
+      resolver.call(value)
+    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)
@@ -246,8 +295,9 @@ module NxtRegistry
       @default = options.fetch(:default) { Blank.new }
       @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 } }
+      @resolver = options.fetch(:resolver, ->(val) { val })
+      @key_resolver = options.fetch(:key_resolver, ->(val) { val })
+      @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) } }
@@ -255,27 +305,29 @@ module NxtRegistry
     end
 
     def define_accessors
-      %w[default memoize call resolver transform_keys on_key_already_registered on_key_not_registered].each do |attribute|
+      %w[default memoize call resolver key_resolver transform_keys on_key_already_registered on_key_not_registered].each do |attribute|
         define_singleton_method attribute do |value = Blank.new, &block|
           value = block if block
 
           if is_a_blank?(value)
             instance_variable_get("@#{attribute}")
           else
+            options[attribute.to_sym] ||= value
             instance_variable_set("@#{attribute}", value)
           end
         end
 
         define_singleton_method "#{attribute}=" do |value|
+          options[attribute.to_sym] ||= value
           instance_variable_set("@#{attribute}", value)
         end
       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 +357,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
@@ -326,5 +372,16 @@ module NxtRegistry
     def raise_invalid_accessor_name(name)
       raise ArgumentError, "#{self} already implements a method named: #{name}. Please choose a different accessor name"
     end
+
+    def initialize_copy(original)
+      super
+
+      @mutex = Mutex.new
+      containers = %i[store options]
+      variables = %i[patterns required_keys allowed_keys namespace on_key_already_registered on_key_not_registered]
+
+      containers.each { |c| instance_variable_set("@#{c}", original.send(c).deep_dup) }
+      variables.each { |v| instance_variable_set("@#{v}", original.send(v).dup) }
+    end
   end
 end

data/lib/nxt_registry/version.rb

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

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: nxt_registry
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.10
 platform: ruby
 authors:
 - Andreas Robecke
 - Nils Sommer
 - Raphael Kallensee
 - Lütfi Demirci
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-04 00:00:00.000000000 Z
+date: 2021-06-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -83,7 +83,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - a.robecke@hellogetsafe.com
 - andreas@robecke.de
@@ -106,7 +106,6 @@ 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
@@ -122,7 +121,7 @@ metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/nxt-insurance
   source_code_uri: https://github.com/nxt-insurance/nxt_registry
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -137,8 +136,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: nxt_registry is a simple implementation of the container pattern
 test_files: []

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