racket-registry 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: efdb66903525e8c25d4c9254fabeec1ba8171650
-  data.tar.gz: 30839afe56b0fd154c0cb1b99b4baa1e026055be
+  metadata.gz: 31b9bb4acd5196231c25d80c686699265a067de5
+  data.tar.gz: 4c98a4ed25abb3e19b04ce7216f6d652342787d7
 SHA512:
-  metadata.gz: 6c1f7bf54264adcbb648b9c3c322a7cce347caea3d9c84d14b6a880c6636d16b6e11c398cb5eb3cc9ca980fede07c638e2c8518ddaaf66ec70975e97b4c94de6
-  data.tar.gz: 76634886929c092c1f44c412a2443c94f7fafe63e925ef20501e6bb501ec79cff0573fba5445faa2a348a5ecc05edfe6ecdc5cb3963ae2cd429d76f650c8beb3
+  metadata.gz: a0f7c55a4f64240e15a333bfe964e51df7a240d5a96372a00badb56fe8d264f0ea5e3dc95bad780e70272af002f8553af9ee9a41417c8723e75a411e7446333e
+  data.tar.gz: 80ae5cdebbacb32a0a15503597cea2364aa1dea17672ff5dba504f3566ba3dfd81937cb112bc633bd209bd2412d6c6fae343a41b2885f8275a44d518350ea3d3

data/lib/racket/registry.rb

@@ -25,12 +25,12 @@ module Racket
     # @param [String|Symbol] key
     # @return [nil]
     def forget(key)
-      self.class.forget(obj: self, key: key)
+      Helper.forget(obj: self, key: key)
     end
 
     # Removes all callbacks from the registry.
     def forget_all
-      self.class.forget_all(obj: self)
+      Helper.forget_all(obj: self)
     end
 
     # Registers a new callback in the registry. This will add a new method
@@ -43,9 +43,7 @@ module Racket
     # @param [Proc|nil] proc
     # @return [nil]
     def register(key, proc = nil, &block)
-      self.class.register(
-        obj: self, key: key, proc: proc, block: block
-      )
+      Helper.register(obj: self, key: key, proc: proc, block: block)
     end
 
     # Registers a new callback in the registry. This will add a new method
@@ -58,110 +56,93 @@ module Racket
     # @param [Proc|nil] proc
     # @return [nil]
     def register_singleton(key, proc = nil, &block)
-      self.class.register_singleton(
-        obj: self, key: key, proc: proc, block: block
-      )
+      Helper.register_singleton(obj: self, key: key, proc: proc, block: block)
     end
 
     alias singleton register_singleton
 
-    # 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
+    # Private helper module for Racket Registry
+    module Helper
+      # Private method - do not call
+      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
+
+      # Private method - do not call
+      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
+
+      # Private method - do not call
+      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
+
+      # Private method - do not call
+      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
+    end
+
+    private_constant :Helper
 
     # Exception class used when a user tries to register an
     # invalid callback.

metadata

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