y_support 2.0.43 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a7f4a0b0a8c590f42dd23407f86cccce3ea0b95b
-  data.tar.gz: 2cb43420440e01d7932a373aa197204f3b7115d3
+  metadata.gz: d09cacddac5d80bc24a3064513b05fe98bb55535
+  data.tar.gz: a17182ae74bb384a3c4d13abf7dc34c3a4bf5060
 SHA512:
-  metadata.gz: 13398ec84e28cd5fdda66ccd6b040f403129a74ddc88cb3b91a264117e08a0469cba1e0006cc5d03c541e697fb17b60c41248fb711b26a9ab0a240a21c08467b
-  data.tar.gz: 5e3031f03fd0de7d043ace4d4b7e5c7a1f1a04ae042f6869c14bfa1e67776035efe804dd9ade11c999f441bf10c2f1a6856ca8b610f44509d4fcc257c3238a98
+  metadata.gz: 148b04b34ba5dc66cb8d09543ae78c8558203fd8107844c0958a06e609c9dced068bbbce52052a1a66040dafa199e6a6d8f95269f6fb3fc8402a5151d4500dba
+  data.tar.gz: bb923dc9a8b48d19bd89705e104f63251078c5e78800bbaac7b58dc182b1000e6514d3241f57b077963038af8f1b0daae2f8fd5cc454dfd55e0839cbf308688e

data/lib/y_support/name_magic/class_methods.rb

@@ -4,30 +4,168 @@ module NameMagic::ClassMethods
   # Presents the instances registered by the namespace. Takes one optional
   # argument. If set to _false_, the method returns all the instances
   # registered by the namespace. If set to _true_ (default), only returns
-  # those instances registered by the namespace, which are of the exact same
-  # class as the method's receiver. Example:
-  #
-  #   class Animal; include NameMagic end
-  #   Cat, Dog = Class.new( Animal ), Class.new( Animal )
-  #   Spot = Dog.new
-  #   Livia = Cat.new
-  #   Animal.instances #=> returns 2 instances
-  #   Dog.instances #=> returns 1 instance
-  #   Dog.instances( false ) #=> returns 2 instances of the namespace Animal
+  # those instances registered by the namespace, which are of exactly the same
+  # class as the receiver. Example:
+  # 
+  # <code>
+  # class Animal; include NameMagic end
+  # Cat, Dog = Class.new( Animal ), Class.new( Animal )
+  # Spot = Dog.new
+  # Livia = Cat.new
+  # Animal.instances #=> returns 2 instances (2 animals)
+  # Dog.instances #=> returns 1 instance (only 1 is of Dog subclass)
+  # Dog.instances( false ) #=> 2 instances again (all the animals)
+  # </code>
   #
-  def instances option=false
-    const_magic
-    return __instances__.keys if option
-    __instances__.keys.select { |i| i.kind_of? self }
+  def instances option=true
+    return super if namespace == self
+    ii = namespace.instances
+    option ? ii.select { |i| i.kind_of? self } : ii
   end
 
   # Presents the instance names. Takes one optional argument, same as
-  # #instances method. Unnamed instances are completely disregarded.
+  # +#instances+ method.
   #
-  def instance_names option=false
+  def instance_names option=true
     instances( option ).names( false )
   end
 
+  # Presents namespace-owned +@instances+ hash. The hash consists of pairs
+  # <code>{ instance => instance_name }</code>. Unnamed instances have +nil+
+  # assigned to them as their name. (The method does not trigger
+  # +#const_magic+.)
+  # 
+  def __instances__
+    return super if namespace == self
+    namespace.__instances__
+  end
+
+  # Presents namespace-owned +@avid_instances+ (array of avid instances). "Avid"
+  # means that the instance is able to overwrite a name used by another
+  # registered instance. (This method does not trigger +#const_magic+.)
+  # 
+  def __avid_instances__
+    return super if namespace == self
+    namespace.__avid_instances__
+  end
+
+  # Returns the instance identified by the first argument, which can typically
+  # be a name (string/symbol). If a registered instance is supplied, it is
+  # returned without change. The second argument is optional, with the same
+  # meaning as in +NameMagic::ClassMethods#instances+ method.
+  # 
+  def instance id, option=true
+    return super if namespace == self
+    namespace.instance( id ).tap { |inst|
+      fail NameError, "No #{self} instance #{id} registered in " +
+        "#{namespace}!" unless inst.kind_of? self if option
+    }
+  end
+
+  # Searches all the modules in the the object space for constants containing
+  # receiver class objects, and names the found instances accordingly. The
+  # number of the remaining nameless instances is returned.
+  #
+  def const_magic
+    puts "#{self}#const_magic invoked!" if ::NameMagic::DEBUG
+    return super if namespace == self
+    puts "self is not namespace, #const_magic delegated to #{namespace}" if ::NameMagic::DEBUG
+    namespace.const_magic
+  end
+
+  # Returns the nameless instances. The optional argument has the same meaning
+  # as in +NameMagic::ClassMethods#instances+ method.
+  # 
+  def nameless_instances option=true
+    return super if namespace == self
+    ii = namespace.nameless_instances
+    option ? ii.select { |i| i.kind_of? self } : ii
+  end
+
+  # Clears namespace-owned references to a specified instance. (This is
+  # different from "unnaming" an instance by setting <code>inst.name =
+  # nil</code>, which makes the instance anonymous, but still registered.)
+  # 
+  def forget instance_identifier, option=true
+    if namespace == self || ! option then super else
+      namespace.forget instance( instance_identifier )
+    end
+  end
+
+  # Clears namespace-owned references to an instance, without performing
+  # #const_magic first. The argument should be a registered instance. Returns
+  # the instance name, or _false_, if there was no such registered instance.
+  # 
+  def __forget__( instance, option=true )
+    return super if namespace == self
+    fail NameError, "Supplied argument not an instance of #{self}!" unless
+      instance.is_a? self if option
+    namespace.__forget__ instance
+  end
+
+  # Clears namespace-owned references to all the anonymous instances.
+  # 
+  def forget_nameless_instances
+    return super if namespace == self
+    namespace.forget_nameless_instances
+  end
+
+  # Clears namespace-owned references to all the instances.
+  # 
+  def forget_all_instances
+    return super if namespace == self
+    namespace.forget_all_instances
+  end
+
+  # Registers a hook to execute upon instantiation. Expects a unary block, whose
+  # argument represents the new instance. It is called right after instantiation,
+  # but before naming the instance.
+  # 
+  def new_instance_hook &block
+    return super if namespace == self
+    namespace.new_instance_hook &block
+  end
+
+  # Registers a hook to execute upon instance naming. Expects a ternary block,
+  # with arguments instance, name, old_name, representing respectively the
+  # instance to be named, the requested name, and the previous name of that
+  # instance (if any). The output of the block should be the name to actually
+  # be used. In other words, the hook can be used (among other things) to check
+  # and/or modify the requested name when christening the instance. It is the
+  # responsibility of this block to output a symbol that can be used as a Ruby
+  # constant name.
+  # 
+  def name_set_hook &block
+    return super if namespace == self
+    namespace.name_set_hook &block
+  end
+
+  # Registers a hook to execute whenever the instance is asked its name. The
+  # instance names are objects that are kept in a hash referred to by
+  # +@instances+ variable owned by the namespace. Normally, +NameMagic#name+
+  # simply returns the name of the instance, as found in the +@instances+ hash.
+  # When +name_get_hook+ is defined, this name is transformed by it before being
+  # returned.
+  # 
+  def name_get_hook &block
+    return super if namespace == self
+    namespace.name_get_hook &block
+  end
+
+  # Sets the namespace of the class.
+  # 
+  def namespace= modul
+    puts "Assigning #{modul} as the namespace of #{self}." if ::NameMagic::DEBUG 
+    modul.extend ::NameMagic::NamespaceMethods
+    define_singleton_method :namespace do modul end
+  end
+
+  # Sets the namespace for the class to self.
+  # 
+  def namespace!
+    nil.tap { self.namespace = self }
+  end
+
   # In addition the ability to name objects upon constant assignment, as common
   # with eg. Class instances, NameMagic redefines class method #new so that it
   # swallows the named argument :name (alias :ɴ), and takes care of naming the
@@ -36,23 +174,21 @@ module NameMagic::ClassMethods
   # another object) if set to _true_.
   # 
   def new *args, &block
-    oo = args[-1].is_a?( Hash ) ? args.pop : {} # extract hash
-    nm = if oo[:name] then oo.delete :name       # consume :name if supplied
-         elsif oo[:ɴ] then oo.delete :ɴ          # consume :ɴ if supplied
-         else nil end
-    avid = oo[:name_avid] ? oo.delete( :name_avid ) : false # => true/false
+    oo = if args[-1].is_a? Hash then args.pop else {} end  # extract hash
+    nm = oo.delete( :name ) || oo.delete( :ɴ )   # consume :name / :ɴ if given
+    avid = !!oo.delete( :name_avid )
     # Avoid overwriting existing names unless avid:
     fail NameError, "#{self} instance #{nm} already exists!" if
       __instances__.keys.include? nm unless avid
     args << oo unless oo.empty?    # prepare the arguments
-    new_before_name_magic( *args, &block ).tap do |new_inst| # instantiate
-      __instances__.update new_inst => nil # Instance is created unnamed...
-      namespace.new_instance_closure.tap { |λ|
-        λ.( new_inst ) if λ
-        if nm then # name has been supplied, we can name the instance:
-          avid ? new_inst.name!( nm ) : new_inst.name = nm
-        else # name hasn't been supplied, making the instance avid:
-          __avid_instances__ << new_inst
+    super( *args, &block ).tap do |inst| # instantiate
+      __instances__.update( inst => nil ) # Instances are created unnamed...
+      namespace.new_instance_hook.tap { |λ|
+        λ.( inst ) if λ
+        if nm then # Name supplied, name the instance.
+          avid ? inst.name!( nm ) : inst.name = nm
+        else # Name not supplied, make the instance avid.
+          __avid_instances__ << inst
         end
       }
     end
@@ -65,4 +201,20 @@ module NameMagic::ClassMethods
     oo = args[-1].is_a?( Hash ) ? args.pop : {} # extract options
     new *args, oo.update( name_avid: true ), &block
   end
+
+  private
+
+  # Checks all the constants in some module's namespace, recursively.
+  # 
+  def serve_all_modules
+    return super if namespace == self
+    namespace.serve_all_modules
+  end
+
+  # Performs general name validation.
+  # 
+  def validate_name name
+    return super if namespace == self
+    namespace.validate_name name
+  end
 end # module NameMagic::ClassMethods

data/lib/y_support/name_magic/hash.rb

@@ -1,4 +1,4 @@
-# -*- coding: utf-8 -*-
+# encoding: utf-8
 
 class Hash
   # Maps a hash into a hash, whose keys have been replaced with names of the

data/lib/y_support/name_magic/namespace_methods.rb

@@ -1,76 +1,52 @@
-# -*- coding: utf-8 -*-
+# encoding: utf-8
 
 module NameMagic
   module NamespaceMethods
-    # Presents class-owned namespace. By default, this is the class itself, but
-    # may be overriden to use some other module as a namespace.
-    # 
-    def namespace
-      self
-    end
-
-    # Sets the namespace of the class.
-    # 
-    def namespace= modul
-      modul.extend ::NameMagic::NamespaceMethods unless modul == self
-      tap { define_singleton_method :namespace do modul end }
-    end
-
-    # Makes the class/module its own namespace. This is useful especially to tell
-    # the subclasses of a class using NameMagic to maintain their own namespaces.
-    # 
-    def namespace!
-      nil.tap { self.namespace = self }
-    end
-
-    # Presents the instances registered by the namespace.
+    # Presents the instances registered in this namespace.
     #
-    def instances
+    def instances *args
       const_magic
       __instances__.keys
     end
 
-    # Presents the instance names. Takes one optional argument, same as
-    # #instances method. Unnamed instances are completely disregarded.
+    # Presents the instance names registered in this namespace.
     #
-    def instance_names
+    def instance_names *args
       instances.names( false )
     end
 
-    # Presents namespace-owned @instances hash of pairs <code>{ instance =>
-    # instance_name }</code>. Unnamed instances have nil value. (Also, this
-    # method does not trigger #const_magic.)
+    # Presents namespace-owned +@instances+ hash. The hash consists of pairs
+    # <code>{ instance => instance_name }</code>. Unnamed instances have +nil+
+    # assigned to them as their name. (The method does not trigger
+    # +#const_magic+.)
     #
-    def __instances__
-      namespace.instance_variable_get( :@instances ) ||
-        namespace.instance_variable_set( :@instances, {} )
+    def __instances__ *args
+      @instances ||= {}
     end
 
-    # Presents namespace-owned @avid_instances array of avid instances. "Avid"
-    # means that the instance is able to overwrite a name used by another
-    # registered instance. (Also, this method does not trigger const_magic).
+    # Avid instances registered in this namespace. ("Avid" means that the
+    # instance is able to steal (overwrite) a name from another registered
+    # instance. (The method does not trigger +#const_magic+.)
     #
-    def __avid_instances__
-      namespace.instance_variable_get( :@avid_instances ) ||
-        namespace.instance_variable_set( :@avid_instances, [] )
+    def __avid_instances__ *args
+      @avid_instances ||= []
     end
 
-    # Returns the instance identified by the argument. NameError is raised, if
-    # the argument does not identify an instance. (It can be an instance name
-    # (string/symbol), or an instance itself, in which case, it is just returned
-    # back without changes.)
+    # Returns the instance identified by the argument, which can be typically
+    # a name (string/symbol). If a registered instance is supplied, it will be
+    # returned unchanged.
     #
-    def instance identifier
-      puts "#instance( #{identifier} )" if DEBUG
+    def instance id, *args
+      # puts "#instance( #{identifier} )" if DEBUG
       # In @instances hash, value 'nil' indicates a nameless instance!
-      fail TypeError, "'nil' is not an instance identifier!" if identifier.nil?
+      fail TypeError, "'nil' is not an instance identifier!" if id.nil?
       ii = instances
-      return identifier if ii.include? identifier # return the instance back
+      return id if ii.include? id # return the instance back
       begin # identifier not a registered instace -- treat it as a name
-        ary = [identifier, identifier.to_sym]
-        ii.find do |i| ary.include? i.name end
+        ary = [id, id.to_sym]
+        ii.find { |inst| ary.include? inst.name }
       rescue NoMethodError
-      end or raise NameError, "No instance #{identifier} in #{self}."
+      end or fail NameError, "No instance #{id} in #{self}."
     end
 
     # Searches all the modules in the the object space for constants containing
@@ -78,24 +54,23 @@ module NameMagic
     # number of the remaining nameless instances is returned.
     #
     def const_magic
+      puts "#{self}#const_magic invoked!" if ::NameMagic::DEBUG
       return 0 if nameless_instances.size == 0
       serve_all_modules
       return nameless_instances.size
-    end # def const_magic
-
+    end
+    
     # Returns those instances, which are nameless (whose name is set to nil).
     # 
-    def nameless_instances
+    def nameless_instances *args
       __instances__.select { |key, val| val.nil? }.keys
     end
-    alias unnamed_instances nameless_instances
-    alias anonymous_instances nameless_instances
 
     # Clears namespace-owned references to a specified instance. (This is
     # different from "unnaming" an instance by setting <code>inst.name =
     # nil</code>, which makes the instance anonymous, but still registered.)
     # 
-    def forget( instance_identifier )
+    def forget instance_identifier, *args
       inst = begin
                instance( instance_identifier )
              rescue ArgumentError
@@ -112,7 +87,7 @@ module NameMagic
     # #const_magic first. The argument should be a registered instance. Returns
     # the instance name, or _false_, if there was no such registered instance.
     # 
-    def __forget__( instance )
+    def __forget__( instance, *args )
       return false unless __instances__.keys.include? instance
       namespace.send :remove_const, instance.name if instance.name
       __avid_instances__.delete( instance )
@@ -127,8 +102,6 @@ module NameMagic
         __avid_instances__.delete inst # also from here
       }
     end
-    alias forget_unnamed_instances forget_nameless_instances
-    alias forget_anonymous_instances forget_nameless_instances
 
     # Clears namespace-owned references to all the instances.
     # 
@@ -139,48 +112,50 @@ module NameMagic
       }
     end
 
-    # Registers a hook to execute whenever name magic creates a new instance of
-    # the class including NameMagic. The block should take one argument (the new
-    # instance that was created) and is called in #new method right after
-    # instantiation, but before naming.
+    # Registers a hook to execute upon instantiation. Expects a unary block, whose
+    # argument represents the new instance. It is called right after instantiation,
+    # but before naming the instance.
     # 
-    def new_instance_closure &block
-      namespace.new_instance_closure &block unless namespace == self
-      @new_instance_closure = block if block
-      @new_instance_closure ||= -> instance { instance }
-    end
-    alias new_instance_hook new_instance_closure
-
-    # Registers a hook to execute whenever name setting is performed on an
-    # instance. The block should take three arguments (instance, name, old_name).
-    # The output value of the block is the name to be actually used – the hook
-    # thus allows to define transformations on the name when naming. It is the
-    # responsibility of the block to output a suitable symbol (capitalized,
-    # usable as a constant name etc.)
+    def new_instance_hook &block
+      @new_instance_hook = block if block
+      @new_instance_hook ||= -> instance { instance }
+    end
+
+    # Registers a hook to execute upon instance naming. Expects a ternary block,
+    # with arguments instance, name, old_name, representing respectively the
+    # instance to be named, the requested name, and the previous name of that
+    # instance (if any). The output of the block should be the name to actually
+    # be used. In other words, the hook can be used (among other things) to check
+    # and/or modify the requested name when christening the instance. It is the
+    # responsibility of this block to output a symbol that can be used as a Ruby
+    # constant name.
     # 
-    def name_set_closure &block
-      namespace.name_set_closure &block unless namespace == self
-      @name_set_closure = block if block
-      @name_set_closure ||= -> name, instance, old_name=nil { name }
+    def name_set_hook &block
+      @name_set_hook = block if block
+      @name_set_hook ||= -> name, instance, old_name=nil { name }
     end
-    alias name_set_hook name_set_closure
 
-    # Registers a hook to execute whenever the instance is asked about its
-    # name. The name object contained in __instances__[self] is subjected
-    # to the name_get_closure before being returned as instance name.
+    # Registers a hook to execute whenever the instance is asked its name. The
+    # instance names are objects that are kept in a hash referred to by
+    # +@instances+ variable owned by the namespace. Normally, +NameMagic#name+
+    # simply returns the name of the instance, as found in the +@instances+ hash.
+    # When +name_get_hook+ is defined, this name is transformed by it before being
+    # returned.
     # 
-    def name_get_closure &block
-      namespace.name_get_closure &block unless namespace == self
-      @name_get_closure = block if block
-      @name_get_closure ||= -> name { name }
+    def name_get_hook &block
+      @name_get_hook = block if block
+      @name_get_hook ||= -> name { name }
     end
-    alias name_get_hook name_get_closure
 
     private
 
     # Checks all the constants in some module's namespace, recursively.
     # 
     def serve_all_modules
+      if DEBUG then
+        puts "#{self}#serve_all_modules invoked!"
+        if name.nil? then puts "(ancestors: #{ancestors.take( 4 ).join ', '}" end
+      end
       todo = ( nameless_instances + __avid_instances__ ).map( &:object_id ).uniq
       ObjectSpace.each_object Module do |ɱ|
         ɱ.constants( false ).each do |const_ß|
@@ -189,21 +164,19 @@ module NameMagic
           rescue LoadError, StandardError; next end
           next unless todo.include? ◉.object_id
           puts "NameMagic: Anonymous object under #{const_ß}!" if DEBUG
-          if __avid_instances__.map( &:object_id ).include? ◉.object_id # avid
-            puts "NameMagic: It is avid." if DEBUG
-            __avid_instances__       # 1. remove from avid list
-              .delete_if { |inst| inst.object_id == ◉.object_id }
-            ◉.name! const_ß          # 2. name rudely
-          else puts "NameMagic: It is not avid." if DEBUG # not avid
-            ɴ = validate_name( name_set_closure.( const_ß, ◉, nil ) ).to_sym
+          if ◉.avid? then puts "NameMagic: It is avid." if DEBUG
+            ◉.make_not_avid!    # 1. Remove it from the list of avid instances.
+            ◉.name! const_ß     # 2. Name it rudely.
+          else puts "NameMagic: It is not avid." if DEBUG
+            ɴ = validate_name( name_set_hook.( const_ß, ◉, nil ) ).to_sym
             puts "NameMagic: Name adjusted to #{ɴ}." if DEBUG
-            conflicter = begin; namespace.const_get( ɴ ); rescue NameError; end
+            conflicter = begin; const_get( ɴ ); rescue NameError; end
             if conflicter then
               msg = "Another #{self}-registered instance named '#{ɴ}' exists!"
               fail NameError, msg unless conflicter == ◉
             else # add the instance to the namespace
               __instances__.update( ◉ => ɴ )
-              namespace.const_set( ɴ, ◉ )
+              const_set( ɴ, ◉ )
             end
           end
           todo.delete ◉.object_id # remove the id from todo list

data/lib/y_support/name_magic.rb

@@ -71,25 +71,22 @@ require_relative 'name_magic/class_methods'
 module NameMagic
   DEBUG = false
 
-  def self.included modul
-    if modul.is_a? Class then # decorate #new
-      class << modul
-        alias :new_before_name_magic :new
-      end
-      modul.extend NameMagic::NamespaceMethods
-      modul.extend NameMagic::ClassMethods
-      # Attach namespace methods also to the namespace, if given
-      begin
-        if modul.namespace == modul then
-          modul.define_singleton_method :namespace do modul end
-        else
-          modul.namespace.extend NameMagic::NamespaceMethods
+  def self.included target
+    if target.is_a? Class then # decorate #new
+      class << target
+        # Primer that sets the namespace of the class to self if the user has
+        # not defined otherwise when this method is first called.
+        # 
+        def namespace
+          extend ::NameMagic::NamespaceMethods
+          define_singleton_method :namespace do self end # redefines itself
+          namespace
         end
-      rescue NoMethodError
       end
+      target.singleton_class.class_exec { prepend NameMagic::ClassMethods }
     else # it is a Module -- infect it with this #include
-      orig, this = modul.method( :included ), method( :included )
-      modul.define_singleton_method :included do |m| this.( m ); orig.( m ) end
+      orig, this = target.method( :included ), method( :included )
+      target.define_singleton_method :included do |m| this.( m ); orig.( m ) end
     end
   end # self.included
 
@@ -111,24 +108,24 @@ module NameMagic
   # 
   def __name__
     ɴ = self.class.__instances__[ self ]
-    namespace.name_get_closure.( ɴ ) if ɴ
+    namespace.name_get_hook.( ɴ ) if ɴ
   end
 
   # Names an instance, cautiously (ie. no overwriting of existing names).
   # 
   def name=( ɴ )
     old_ɴ = namespace.__instances__[ self ]    # previous name
-    if ɴ then puts "NameMagic: Naming with argument #{ɴ}." if DEBUG
-      ɴ = namespace.send( :validate_name,     # honor the hook
-                          namespace.name_set_closure.( ɴ, self, old_ɴ ) ).to_sym
-      puts "NameMagic: Name adjusted to #{ɴ}." if DEBUG
+    if ɴ then # puts "NameMagic: Naming with argument #{ɴ}." if DEBUG
+      ɴ = namespace.send( :validate_name,      # honor the hook
+                          namespace.name_set_hook.( ɴ, self, old_ɴ ) ).to_sym
+      # puts "NameMagic: Name adjusted to #{ɴ}." if DEBUG
       return if old_ɴ == ɴ                     # already named as required
       fail NameError, "Name '#{ɴ}' already exists in #{namespace} namespace!" if
         self.class.__instances__.rassoc( ɴ )
       namespace.const_set ɴ, self           # write a constant
       namespace.__instances__[ self ] = ɴ   # write to @instances
       namespace.__forget__ old_ɴ            # forget the old name of self
-    else puts "NameMagic: Unnaming #{old_ɴ || self}" if DEBUG
+    else # puts "NameMagic: Unnaming #{old_ɴ || self}" if DEBUG
       namespace.__instances__.update( self => nil ) # unname in @instances
       namespace.send :remove_const, old_ɴ if old_ɴ  # remove namespace const.
     end
@@ -138,10 +135,10 @@ module NameMagic
   # 
   def name!( ɴ )
     old_ɴ = namespace.__instances__[ self ]   # previous name
-    if ɴ then puts "NameMagic: Rudely naming with #{ɴ}." if DEBUG
+    if ɴ then # puts "NameMagic: Rudely naming with #{ɴ}." if DEBUG
       ɴ = namespace.send( :validate_name,     # honor the hook
-                          namespace.name_set_closure.( ɴ, self, old_ɴ ) ).to_sym
-      puts "NameMagic: Name adjusted to #{ɴ}." if DEBUG
+                          namespace.name_set_hook.( ɴ, self, old_ɴ ) ).to_sym
+      # puts "NameMagic: Name adjusted to #{ɴ}." if DEBUG
       return false if old_ɴ == ɴ # already named as required
       pair = namespace.__instances__.rassoc( ɴ )
       namespace.__forget__( pair[0] ) if pair # rudely forget the collider
@@ -152,4 +149,16 @@ module NameMagic
       self.name = nil # unnaming, no collider issues
     end
   end
+
+  # Is the instance avid for a name? (Will it overwrite other instance names?)
+  # 
+  def avid?
+    namespace.__avid_instances__.any? &method( :equal? )
+  end
+
+  # Make the instance not avid.
+  # 
+  def make_not_avid!
+    namespace.__avid_instances__.delete_if { |i| i.object_id == object_id }
+  end
 end # module NameMagic

data/lib/y_support/version.rb

@@ -1,4 +1,4 @@
 module YSupport
-  VERSION = "2.0.43"
+  VERSION = "2.1.0"
   DEBUG = false
 end

data/test/name_magic_test.rb

@@ -11,18 +11,20 @@ describe NameMagic do
     @reporter = Object.new
     puts "..."
     @reporter.singleton_class.class_exec { attr_reader :report, :naming }
-    @ç.namespace.new_instance_closure do |instance|
+    @ç.ancestors.must_include NameMagic
+    @ç.singleton_class.ancestors.must_include NameMagic::ClassMethods
+    @ç.namespace.new_instance_hook do |instance|
       @reporter.define_singleton_method :report do "Instance reported" end
     end
-    @ç.namespace.name_set_closure do |name, instance, old_name|
+    @ç.namespace.name_set_hook do |name, instance, old_name|
       @reporter.define_singleton_method :name_set do
         "Name of the new instance was #{name}"
       end
       name
     end
-    @ç.name_get_closure do |name_object|
+    @ç.name_get_hook do |name_object|
       @reporter.define_singleton_method :name_get do
-        "Name get closure called on #{name_object}"
+        "Name get hook called on #{name_object}"
       end
       name_object
     end
@@ -37,7 +39,7 @@ describe NameMagic do
     @reporter.report.must_equal "Instance reported"
     @reporter.name_set.must_equal "Name of the new instance was Boris"
     x.name.must_equal :Boris
-    @reporter.name_get.must_equal "Name get closure called on Boris"
+    @reporter.name_get.must_equal "Name get hook called on Boris"
     ufo = @ç.new
     @ç.nameless_instances.must_equal [ufo]
     UFO = @ç.new
@@ -45,17 +47,21 @@ describe NameMagic do
     @reporter.name_set.must_equal "Name of the new instance was Boris"
     UFO.name
     @reporter.name_set.must_equal "Name of the new instance was UFO"
-    @reporter.name_get.must_equal "Name get closure called on UFO"
+    @reporter.name_get.must_equal "Name get hook called on UFO"
     Elaine = @ç.new
     Elaine.name.must_equal :Elaine
     m = Module.new
     XXX = m
     @ç.namespace = XXX
     @ç.namespace.must_equal m
+    @ç.singleton_class.must_include ::NameMagic::ClassMethods
+    m.singleton_class.must_include ::NameMagic::NamespaceMethods
     Rover = @ç.new
+    @ç.namespace.must_equal XXX
+    @ç.nameless_instances.must_equal [ Rover ]
     @ç.const_magic
-    XXX::Rover.must_be_kind_of @ç
     Rover.name.must_equal :Rover
+    XXX::Rover.must_be_kind_of @ç
     @ç.namespace!
     Spot = @ç.new
     @ç.const_magic

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: y_support
 version: !ruby/object:Gem::Version
-  version: 2.0.43
+  version: 2.1.0
 platform: ruby
 authors:
 - boris
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-21 00:00:00.000000000 Z
+date: 2013-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport