nxt_registry 0.3.0 → 0.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84faa74573904a66ff0f574195ef5ab7e74508d097f04d1e7f43afcfe4867432
-  data.tar.gz: 8f5c04f6eef2f3b7328567d2b1e49fe9e862d915b572e18fdefd32cb71c24fc2
+  metadata.gz: e3c1e56b8913dea9833ea5fac4b1b837389de5df7aa269f3b2f04977f2ddceb3
+  data.tar.gz: 782bcb6ecce2753f77b488c29806bf1b2127714fe82aeed8ab2564297a43b95b
 SHA512:
-  metadata.gz: 293d5d1d418152c704ea04aaff4dd392b901c40a9460f1858e5cf6581a0c6fe58041bbe163b8aff3fbcdd9848638f7715e87046b14666f5111677c5241d67eea
-  data.tar.gz: 0475b0d48a589d90ff548d2c7f414bab38e5360fb46cafee35a29e83203a72fcd8fbce4870fbd7862b182ac38558f48567417808c5d400f4a728ff7dbf353a53
+  metadata.gz: 1e512d832f3d40ae60ffcfad8578589138c1f00479c2d2dab797c7e9faa6a37cec77da419d671715af55629e0efeac09ef5761bf39afcafe077c0d6f6af740a0
+  data.tar.gz: 3f17bfcc73233107e2daa4db54905115aea50e6f926b8e7ed10aea6d098ff418a4f39ced0e688b02a0a207e0562f02274bdfd9f59d568734485454afe7e1f06d

data/CHANGELOG.md

@@ -1,3 +1,24 @@
+# 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
+
+# v0.3.1 2020-09-23
+
+- Allow to define custom accessors for registries
+
 # v0.3.0 2020-09-10
 
 ### Breaking Changes

data/Gemfile.lock

@@ -1,13 +1,13 @@
 PATH
   remote: .
   specs:
-    nxt_registry (0.3.0)
+    nxt_registry (0.3.5)
       activesupport
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3.3)
+    activesupport (6.0.3.4)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -24,25 +24,25 @@ GEM
       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

@@ -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 register 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.
@@ -130,17 +153,41 @@ class Layer
   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.

data/lib/nxt_registry.rb

@@ -1,32 +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/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'
+require 'nxt_registry/singleton'
 
 module NxtRegistry
   def registry(name, **options, &config)
-    return registries.fetch(name) if registries.key?(name)
-
-    registry = Registry.new(name, **options, &config)
-    registries[name] ||= registry
-    registry
+    build_registry(Registry, name, **options, &config)
   end
 
   def recursive_registry(name, **options, &config)
-    return registries.fetch(name) if registries.key?(name)
-
-    registry = RecursiveRegistry.new(name, **options, &config)
-    registries[name] ||= registry
-    registry
+    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 ||= {}
+    @registries ||= Registry.new(:registries)
   end
 end

data/lib/nxt_registry/registry.rb

@@ -1,25 +1,28 @@
 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
+      @patterns = []
 
       setup_defaults(options)
       configure(&config)
     end
 
     attr_reader :name
+    attr_accessor :configured
 
     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 = RegistryBuilder.new do
@@ -36,13 +39,13 @@ module NxtRegistry
     end
 
     def registry(name, **options, &config)
-      options = options.merge(parent: self)
-      register(name, Registry.new(name, **options, &config))
+      opts = options.merge(parent: self)
+      register(name, Registry.new(name, **opts, &config))
     end
 
     def registry!(name, **options, &config)
-      options = options.merge(parent: self)
-      register!(name, Registry.new(name, **options, &config))
+      opts = options.merge(parent: self)
+      register!(name, Registry.new(name, **opts, &config))
     end
 
     def attr(name)
@@ -61,37 +64,37 @@ module NxtRegistry
 
     def register(key = Blank.new, value = Blank.new, **options, &block)
       if block_given?
-        if value.is_a?(Blank)
+        if is_a_blank?(value)
           registry(key, **options, &block)
         else
           raise_register_argument_error
         end
       else
-        __register(key, value, raise: true)
+        __register(key, value, raise_on_key_already_registered: true)
       end
     end
 
     def register!(key = Blank.new, value = Blank.new, **options, &block)
       if block_given?
-        if value.is_a?(Blank)
+        if is_a_blank?(value)
           registry!(key, **options, &block)
         else
           raise_register_argument_error
         end
       else
-        __register(key, value, raise: false)
+        __register(key, value, raise_on_key_already_registered: false)
       end
     end
 
     def resolve!(*keys)
       keys.inject(self) do |current_registry, key|
-        current_registry.send(:__resolve, key, raise: true)
+        current_registry.send(:__resolve, key, raise_on_key_not_registered: true)
       end
     end
 
     def resolve(*keys)
       keys.inject(self) do |current_registry, key|
-        current_registry.send(:__resolve, key, raise: false) || break
+        current_registry.send(:__resolve, key, raise_on_key_not_registered: false) || break
       end
     end
 
@@ -124,7 +127,8 @@ 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
@@ -141,6 +145,8 @@ module NxtRegistry
           instance_exec(&block)
         end
       end
+
+      self.configured = true
     end
 
     def to_s
@@ -151,33 +157,40 @@ module NxtRegistry
 
     private
 
-    attr_reader :namespace, :parent, :config, :store, :options
-    attr_accessor :is_leaf
+    attr_reader :namespace, :parent, :config, :store, :options, :accessor, :patterns
+    attr_accessor :is_leaf, :interface_defined
 
     def is_leaf?
       @is_leaf
     end
 
-    def __register(key, value, raise: true)
-      key = transformed_key(key)
+    def __register(key, value, raise_on_key_already_registered: true)
+      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)
 
-      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?(key)
           store.fetch(key)
+        elsif (pattern = matching_pattern(key))
+          store.fetch(pattern)
         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
@@ -191,11 +204,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)
@@ -204,30 +213,59 @@ 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
-      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.to_s)
+      accessor_with_bang = "#{accessor}!"
+      raise_invalid_accessor_name(accessor_with_bang) if respond_to?(accessor_with_bang)
+
+      define_singleton_method accessor.to_s 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)
@@ -235,7 +273,8 @@ 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) } }
       @on_key_not_registered = options.fetch(:on_key_not_registered) { ->(key) { raise_key_not_registered_error(key) } }
@@ -246,7 +285,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)
@@ -284,7 +323,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
@@ -296,6 +335,7 @@ module NxtRegistry
       super
       @store = original.send(:store).deep_dup
       @options = original.send(:options).deep_dup
+      @patterns = original.send(:patterns).dup
     end
 
     def build_namespace
@@ -305,5 +345,13 @@ module NxtRegistry
     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/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.0"
+  VERSION = "0.3.5"
 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.3.0
+  version: 0.3.5
 platform: ruby
 authors:
 - Andreas Robecke
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-09-17 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: []
@@ -111,6 +112,7 @@ files:
 - 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