nxt_registry 0.3.3 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f83b8d92a02103b69d4746dfb08e396d827992bc1d1ef21d39fd46d117ce2ac
-  data.tar.gz: ab40f633dbed120132de18dbec3b1707c2cab85114ff5857330add4845db0209
+  metadata.gz: 9d8d5b1247dfc045e077ccf9d79cf3ea010c9c56434133f8210f3b77af439d0d
+  data.tar.gz: 9bd0fc656681a64856f6f21996914ebdeca063ea7cd5585746c29840c4f9694e
 SHA512:
-  metadata.gz: 9f843eec28980bd3ffd49906b0661cdce4a02f4a027cf48845cfff799fcbd58213260790501a104435ec71b7e7261f9ff49239dd1296af1f40dcec383de99a29
-  data.tar.gz: 71cb8513d2eb829bf930a96e244bc6914dbc9f62a78e5fa7916ffc0710765c6393063b055779d22226d718bc52c52fd106f7a3ed8ad44536768a58f28968fe56
+  metadata.gz: c136e4279f1fe2907e43ff24f96a28bdec6cf3b095842831c6a1834b468d174e138a370ede137cd318f879c23579c5664a93c5820e7409b6985d4829f7905f30
+  data.tar.gz: 2793ac826854219b0e5017e84264ce3908b28c1c9148cddef1dd37dc70b761445ab07d7bd7185f5f2cd58a220cdc1bcb065f6fe49e359a1716922db85fe4532f

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+# 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
+- Fix mistakes in readme
+
 # v0.3.3 2020-11-24
 
 - Fix: Pass key to resolver instead of value 

data/Gemfile.lock

@@ -1,26 +1,26 @@
 PATH
   remote: .
   specs:
-    nxt_registry (0.3.3)
+    nxt_registry (0.3.9)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.4)
+    activesupport (6.1.3)
       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.9)
       concurrent-ruby (~> 1.0)
     method_source (1.0.0)
-    minitest (5.14.2)
-    pry (0.13.1)
+    minitest (5.14.4)
+    pry (0.14.0)
       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)
-    zeitwerk (2.4.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
 
@@ -27,24 +26,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 +57,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 +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.
@@ -112,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
 
@@ -165,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
@@ -209,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,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,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,71 +162,110 @@ 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)
+      mutex.synchronize do
+        key = transformed_key(key)
 
-      value = if is_leaf?
-        if store.key?(key)
-          store.fetch(key)
-        else
-          if is_a_blank?(default)
-            return unless raise_on_key_not_registered
+        value = if is_leaf?
+          resolved_key = key_resolver.call(key)
 
-            on_key_not_registered && on_key_not_registered.call(key)
+          if store.key?(resolved_key)
+            store.fetch(resolved_key)
+          elsif (pattern = matching_pattern(resolved_key))
+            store.fetch(pattern)
           else
-            value = resolve_default(key)
-            return value unless memoize
+            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(key)
+              return value unless memoize
 
-            store[key] ||= value
+              store[key] ||= value
+            end
           end
+        else
+          store[key] ||= default.call
         end
-      else
-        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
     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 +296,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 +306,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 +358,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 +373,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/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.3"
+  VERSION = '0.3.9'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt_registry
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.9
 platform: ruby
 authors:
 - Andreas Robecke
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-11-24 00:00:00.000000000 Z
+date: 2021-03-10 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