racket-registry 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d0ba35e3b8ae749a231ddfb8ebc8c1be932123fc
-  data.tar.gz: dd77a4e59f964f4f23cddad580d3942ec5fc8096
+  metadata.gz: efdb66903525e8c25d4c9254fabeec1ba8171650
+  data.tar.gz: 30839afe56b0fd154c0cb1b99b4baa1e026055be
 SHA512:
-  metadata.gz: 61e50e05a2981477850b0f431d8dcfd6c50440829f6b2dd89e78bfe2e3367b38930a0ca7d1404b8fb29d9062aa6bd45da1d728bd4b1b685961843707b4da7413
-  data.tar.gz: 585da05068ae97d15b38247fdfe8c1625f97b18eddb8a4cdec8f3fd97cd310f4eccc06683a3dca703882189c0fb3d5449e597870213eee4a3649b4b18f69594f
+  metadata.gz: 6c1f7bf54264adcbb648b9c3c322a7cce347caea3d9c84d14b6a880c6636d16b6e11c398cb5eb3cc9ca980fede07c638e2c8518ddaaf66ec70975e97b4c94de6
+  data.tar.gz: 76634886929c092c1f44c412a2443c94f7fafe63e925ef20501e6bb501ec79cff0573fba5445faa2a348a5ecc05edfe6ecdc5cb3963ae2cd429d76f650c8beb3

data/README.md

@@ -8,7 +8,7 @@ Racket Registry was originally intended for use in my home-made web framework, [
 The intention of the this library is to provide a very simple dependency injection container. Although not as useful in ruby as in less dynamic languages, I still think using a service container has its uses.
 
 ## How?
-Racket Registry allows you to register two kinds of procs, non-singletons and singletons. Registering also means that the container gets a new public method corresponding to the key used when registering the proc.
+Racket Registry allows you to register two kinds of callbacks, non-singletons and singletons. Registering also means that the container gets a new public method corresponding to the key used when registering the callback.
 
 ```ruby
 require 'racket/registry'
@@ -83,5 +83,10 @@ registry.register(:foo, lambda { Object.new })
 registry.register(:foo) { Object.new }
 ```
 
+## "Unregistering" callbacks
+
+If you want to "unregister" a specific callback, you can use `registry.forget(key)`. If you want to unregister all callbacks,
+you can use `registry.forget_all`.
+
 ## Limitations
-When registering a proc, you must use a string/symbol as key. Since the registry is also defining a new public method, the key must not collide with any public method in Object or Racket::Registry.
+When registering a callback, you must use a string/symbol as key. Since the registry is also defining a new public method, the key must represent a valid method name and also not collide with any public method in the registry.

data/lib/racket/registry.rb

@@ -20,79 +20,167 @@
 module Racket
   # Racket Registry namespace
   class Registry
-    def initialize
-      @resolved = {}
+    # Removes the callback specified by +key+ from the registry.
+    #
+    # @param [String|Symbol] key
+    # @return [nil]
+    def forget(key)
+      self.class.forget(obj: self, key: key)
     end
 
-    # Registers a new proc in the registry. This will add a new method
+    # Removes all callbacks from the registry.
+    def forget_all
+      self.class.forget_all(obj: self)
+    end
+
+    # Registers a new callback in the registry. This will add a new method
     # matching +key+ to the registry that can be used both outside the
-    # registry and when registering other procs dependant of the
-    # current entry. Results from the proc will not be cached, meaning
-    # that the proc may return a different object every time.
+    # registry and when registering other callbacks dependant of the
+    # current entry. Results from the callback will not be cached, meaning
+    # that the callback may return a different object every time.
     #
     # @param [String|Symbol] key
     # @param [Proc|nil] proc
     # @return [nil]
     def register(key, proc = nil, &block)
-      key, proc, proc_args, =
-        ClassMethods.validate_usable([key, self, proc, block, @resolved])
-      singleton_class.instance_eval do
-        define_method(key) { proc.call(*proc_args) }
-      end && nil
+      self.class.register(
+        obj: self, key: key, proc: proc, block: block
+      )
     end
 
-    # Registers a new proc in the registry. This will add a new method
+    # Registers a new callback in the registry. This will add a new method
     # matching +key+ to the registry that can be used both outside the
-    # registry and when registering other procs dependant of the
-    # current entry. Results from the proc will be cached, meaning
-    # that the proc will return the same object every time.
+    # registry and when registering other callbacks dependant of the
+    # current entry. Results from the callnack will be cached, meaning
+    # that the callback will return the same object every time.
     #
     # @param [String|Symbol] key
     # @param [Proc|nil] proc
     # @return [nil]
     def register_singleton(key, proc = nil, &block)
-      key, proc, proc_args, resolved =
-        ClassMethods.validate_usable([key, self, proc, block, @resolved])
-      singleton_class.instance_eval do
-        define_method(key) do
-          return resolved[key] if resolved.key?(key)
-          resolved[key] = proc.call(*proc_args)
-        end
-      end && nil
+      self.class.register_singleton(
+        obj: self, key: key, proc: proc, block: block
+      )
     end
 
     alias singleton register_singleton
 
-    # Racket Registry class methods
-    module ClassMethods
-      # Validates that the parameters sent to the registry is usable.
-      #
-      # @param [Array] args
-      # @return [Array]
-      def self.validate_usable(args)
-        key, obj, proc, block, resolved = args
-        key = validate_key(key, obj)
-        proc = validate_proc(proc, block)
-        [key, proc, proc.arity.zero? ? [] : [obj], resolved]
-      end
-
-      def self.validate_key(key, obj)
-        sym = key.to_sym
-        insp = key.inspect
-        raise "Invalid key #{insp}" if
-          Racket::Registry.public_methods.include?(sym) ||
-          /^[a-z\_]{1}[\d\w\_]*$/ !~ sym
-        raise "Key #{insp} already registered" if obj.respond_to?(key)
-        sym
-      end
-
-      def self.validate_proc(proc, block)
-        return proc if proc.respond_to?(:call)
-        return block if block.respond_to?(:call)
-        raise 'No proc/block given'
-      end
-
-      private_class_method :validate_key, :validate_proc
+    # Removes a callback from a registry.
+    #
+    # @param [Hash] options
+    # @return [nil]
+    def self.forget(options)
+      obj, methods, key = validate_existing(options)
+      raise KeyNotRegisteredError,
+            "Key #{key} is not registered" unless methods.include?(key)
+      obj.singleton_class.instance_eval do
+        @resolved.delete(key) if defined?(@resolved)
+        remove_method(key)
+      end && nil
+    end
+
+    # Removes all callbacks from a registry.
+    #
+    # @param [Hash] options
+    # @return [nil]
+    def self.forget_all(options)
+      obj, methods, = validate_existing(options)
+      obj.singleton_class.instance_eval do
+        @resolved.clear if defined?(@resolved)
+        methods.each { |meth| remove_method(meth) }
+      end && nil
+    end
+
+    # Registers a new callback to a registry. This will add a new method
+    # matching +key+ to the registry that can be used both outside the
+    # registry and when registering other callbacks dependant of the
+    # current entry. Results from the callback will not be cached, meaning
+    # that the callback may return a different object every time.
+    #
+    # @param [Hash] options
+    # @return [nil]
+    def self.register(options)
+      key, proc, proc_args, obj = validate_usable(options)
+      obj.define_singleton_method(key) do
+        proc.call(*proc_args)
+      end && nil
+    end
+
+    # Registers a new callback to a registry. This will add a new method
+    # matching +key+ to the registry that can be used both outside the
+    # registry and when registering other callbacks dependant of the
+    # current entry. Results from the callback will be cached, meaning
+    # that the callback will return the same object every time.
+    #
+    # @param [Hash] options
+    # @return [nil]
+    def self.register_singleton(options)
+      key, proc, proc_args, obj = validate_usable(options)
+      resolved = resolved(options[:obj])
+      obj.define_singleton_method(key) do
+        return resolved[key] if resolved.key?(key)
+        resolved[key] = proc.call(*proc_args)
+      end && nil
+    end
+
+    def self.resolved(obj)
+      obj.singleton_class.instance_eval { @resolved ||= {} }
+    end
+
+    def self.validate_existing(options)
+      result = [options[:obj]]
+      result << result.first.singleton_methods
+      key = options.fetch(:key, nil)
+      result << key.to_sym if key
+      result
+    end
+
+    def self.validate_key(key, obj)
+      sym = key.to_sym
+      insp = key.inspect
+      raise KeyAlreadyRegisteredError, "Key #{insp} already registered" if
+        obj.singleton_methods.include?(sym)
+      raise InvalidKeyError, "Invalid key #{insp}" if
+        obj.public_methods.include?(sym) ||
+        /^[a-z\_]{1}[\d\w\_]*$/ !~ sym
+      sym
+    end
+
+    def self.validate_callback(proc, block)
+      return proc if proc.respond_to?(:call)
+      return block if block.respond_to?(:call)
+      raise InvalidCallbackError, 'Invalid callback'
+    end
+
+    def self.validate_usable(options)
+      obj = options[:obj]
+      key = validate_key(options[:key], obj)
+      proc = validate_callback(options[:proc], options[:block])
+      [key, proc, proc.arity.zero? ? [] : [obj], obj]
+    end
+
+    private_class_method :resolved, :validate_callback,
+                         :validate_existing, :validate_key,
+                         :validate_usable
+
+    # Exception class used when a user tries to register an
+    # invalid callback.
+    class InvalidCallbackError < ArgumentError
+    end
+
+    # Exception class used when a user tries to register an
+    # invalid key.
+    class InvalidKeyError < ArgumentError
+    end
+
+    # Exception class used when a user tries to register a key
+    # that is already registered.
+    class KeyAlreadyRegisteredError < ArgumentError
+    end
+
+    # Exception class used when a user is requesting to forget
+    # a key that is not registered.
+    class KeyNotRegisteredError < ArgumentError
     end
   end
 end

data/spec/racket_registry.rb

@@ -67,24 +67,25 @@ describe 'Racket::Registry registration' do
 
   it 'should block invalid keys' do
     -> { registry.register('inspect') }
-      .should.raise(RuntimeError)
+      .should.raise(Racket::Registry::InvalidKeyError)
       .message.should.equal('Invalid key "inspect"')
   end
 
   it 'should block already registered keys' do
     -> { registry.register('one', -> { Object.new }) }
-      .should.raise(RuntimeError)
+      .should.raise(Racket::Registry::KeyAlreadyRegisteredError)
       .message.should.equal('Key "one" already registered')
   end
 
   it 'should block invalid block/procs' do
     -> { registry.register('invalid') }
-      .should.raise(RuntimeError)
-      .message.should.equal('No proc/block given')
+      .should.raise(Racket::Registry::InvalidCallbackError)
+      .message.should.equal('Invalid callback')
   end
 end
 
 describe 'Racket::Registry dependency handling' do
+  # A very simple class
   class Simple
     attr_reader :text
 
@@ -93,6 +94,7 @@ describe 'Racket::Registry dependency handling' do
     end
   end
 
+  # A somewhat complex class
   class NotSoSimple
     attr_reader :text, :simple_first, :simple_second
 
@@ -103,7 +105,8 @@ describe 'Racket::Registry dependency handling' do
     end
   end
 
-  it 'should be able to resolve dependencies regardless of registration order' do
+  it 'should be able to resolve dependencies regardless of ' \
+     'registration order' do
     registry = Racket::Registry.new
 
     foo = Simple.new('foo')
@@ -111,10 +114,10 @@ describe 'Racket::Registry dependency handling' do
 
     registry.singleton(
       :baz,
-      lambda { |r| NotSoSimple.new('baz', r.foo, r.bar) }
+      ->(r) { NotSoSimple.new('baz', r.foo, r.bar) }
     )
-    registry.singleton(:bar, lambda { |r| bar })
-    registry.singleton(:foo, lambda { |r| foo })
+    registry.singleton(:bar, -> { bar })
+    registry.singleton(:foo, -> { foo })
 
     baz = registry.baz
     baz.simple_first.object_id.should.equal(foo.object_id)
@@ -123,3 +126,32 @@ describe 'Racket::Registry dependency handling' do
     registry.bar.object_id.should.equal(bar.object_id)
   end
 end
+
+describe 'Racket::Registry entry removal' do
+  registry = Racket::Registry.new
+
+  it 'should be able to forget a single entry' do
+    obj = Object.new
+    registry.register(:foo) { obj }
+    registry.foo.object_id.should.equal(obj.object_id)
+    registry.forget(:foo)
+    -> { registry.foo }.should.raise(NoMethodError)
+  end
+
+  it 'should be able to forget all entries' do
+    obj = Object.new
+    registry.register(:foo) { obj }
+    registry.register(:bar) { obj }
+    registry.foo.object_id.should.equal(obj.object_id)
+    registry.bar.object_id.should.equal(obj.object_id)
+    registry.forget_all
+    -> { registry.foo }.should.raise(NoMethodError)
+    -> { registry.bar }.should.raise(NoMethodError)
+  end
+
+  it 'should fail to forget non-existing entries' do
+    -> { registry.forget(:baz) }
+      .should.raise(Racket::Registry::KeyNotRegisteredError)
+      .message.should.equal('Key baz is not registered')
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: racket-registry
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Lars Olsson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-22 00:00:00.000000000 Z
+date: 2016-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bacon