y_support 2.1.18 → 2.4.4

data/test/name_magic_test.rb

@@ -6,70 +6,917 @@ require './../lib/y_support/name_magic'
 
 describe NameMagic do
   before do
-    mod = Module.new do include NameMagic end
-    @ç = Class.new do include mod end
-    @reporter = Object.new
-    puts "..."
-    @reporter.singleton_class.class_exec { attr_reader :report, :naming }
-    @ç.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
+    @c = -> { mod = Module.new do include NameMagic end
+              Class.new do include mod end }
+  end
+
+  describe NameMagic::ClassMethods do
+    it "should carry certain instance methods" do
+      [ :__instances__,
+        :__avid_instances__,
+        :const_magic,
+        :validate_name,
+        :namespace=,
+        :namespace!,
+        :instances,
+        :instance,
+        :nameless_instances,
+        :forget,
+        :__forget__,
+        :forget_nameless_instances,
+        :forget_all_instances,
+        :instantiation_exec,
+        :exec_when_naming,
+        :new,
+      ].each { |ß|
+        NameMagic::ClassMethods.instance_methods.must_include ß
+      }
+    end
+
+    describe ".__instances__" do
+      it "must act as a selector of the instance registry" do
+        c = @c.call
+        c.__instances__.must_be_kind_of Hash
+        c.__instances__.must_be_empty
+        i1 = c.new
+        c.__instances__.to_a.first.must_equal [ i1, nil ]
+        i2 = c.new name: "Joe"
+        c.__instances__.must_equal( { i1 => nil, i2 => :Joe } )
+      end
+    end
+    
+    describe ".__avid_instances__" do
+      it "must return the avid (typically unnamed) instances" do
+        c = @c.call
+        c.__avid_instances__.must_equal []
+        instance = c.new
+        c.__avid_instances__.must_equal [ instance ]
+      end
+    end
+
+    describe ".validate_name" do
+      it "must validate suitable capitalized names" do
+        c = @c.call
+        c.validate_name( :Fred ).must_equal :Fred
+        c.validate_name( "Fred" ).must_equal "Fred"
+        -> { c.validate_name "fred" }.must_raise NameError
+        -> { c.validate_name "Name With Spaces" }
+          .must_raise NameError
+      end
+    end
+
+    describe ".namespace" do
+      it "should return namespace of the user class" do
+        c = @c.call
+        c.namespace.must_equal c
+      end
+    end
+
+    describe ".namespace=" do
+      it "shoud can redefine the namespace of a class" do
+        c, m = @c.call, Module.new
+        d = Class.new c
+        c.namespace.must_equal c
+        c.namespace = m
+        c.namespace.must_equal m
+        d.namespace.must_equal m
+        c, m = @c.call, Module.new
+        d = Class.new c
+        d.namespace.must_equal c
+        d.namespace = m
+        c.namespace.must_equal c
+      end
+
+      it "raises error when instance registry is not empty" do
+        c, m = @c.call, Module.new
+        c.new
+        -> { c.namespace = m }.must_raise StandardError
+      end
+    end
+
+    describe ".namespace!" do
+      it "should work" do
+        c = @c.call
+        subclass = Class.new c
+        refute subclass.namespace == subclass
+        subclass.namespace!
+        assert subclass.namespace == subclass
+      end
+    end
+
+    describe "instance selectors" do
+      before do
+        @human = @c.call
+        @saint = Class.new @human
+        @joe = @human.new name: "Joe"
+        @dick = @saint.new name: "St_IGNUcius"
+      end
+
+      describe ".instances" do
+        it "must return the list of instances in the registry" do
+          @human.instances.must_equal [ @joe, @dick ]
+          @saint.instances.must_equal [ @dick ]
+        end
+      end
+
+      describe ".instance" do
+        it "must return instance reference" do
+          -> { @saint.instance @joe }.must_raise NameError
+          -> { @saint.instance :Joe }.must_raise NameError
+          @human.instance( @joe ).must_equal @joe
+          @human.instance( :Joe ).must_equal @joe
+          @saint.instance( @dick ).must_equal @dick
+          @saint.instance( :St_IGNUcius ).must_equal @dick
+          @human.instance( @dick ).must_equal @dick
+          @human.instance( :St_IGNUcius ).must_equal @dick
+        end
+      end
+
+      describe ".nameless_instances" do
+        it "returns the list of registered nameless instances" do
+          c = @c.call
+          d = Class.new c
+          c.nameless_instances.must_equal []
+          i1 = c.new
+          c.nameless_instances.must_equal [ i1 ]
+          d.nameless_instances.must_equal []
+          i2 = d.new
+          c.nameless_instances.must_equal [ i1, i2 ]
+          d.nameless_instances.must_equal [ i2 ]
+          i1.name = :Foo
+          c.nameless_instances.must_equal [ i2 ]
+          d.nameless_instances.must_equal [ i2 ]
+          i2.name = :Bar
+          c.nameless_instances.must_equal []
+          d.nameless_instances.must_equal []
+        end
+      end
     end
-    @ç.namespace.name_set_hook do |name, instance, old_name|
-      @reporter.define_singleton_method :name_set do
-        "Name of the new instance was #{name}"
+
+    describe "forgetting instances" do
+      before do
+        @human = @c.call
+        @saint = Class.new @human
+        @joe = @human.new name: "Joe"
+        @dick = @saint.new name: "St_IGNUcius"
+      end
+
+      describe ".forget" do
+        it "should clear the given instance from the registry" do
+          -> { @saint.forget @joe }.must_raise NameError
+          @human.forget( :Joe ).must_equal @joe
+          @saint.forget( @dick ).must_equal @dick
+          @human.instances.must_equal []
+        end
+      end
+
+      describe ".__forget__" do
+        it "shoulf forget instance without doing #const_magic" do
+          -> { @saint.__forget__ @joe }.must_raise TypeError
+          -> { @human.__forget__ :Joe }.must_raise TypeError
+          @saint.__forget__( @dick ).must_equal :St_IGNUcius
+          i = @saint.new
+          @saint.__forget__( i ).must_equal nil
+        end
+      end
+
+      describe ".forget_nameless_instances" do
+        it "should unregister anonymous instances" do
+          i, j = @human.new, @human.new
+          @human.nameless_instances.must_equal [ i, j ]
+          Fred = i
+          @human.forget_nameless_instances
+          @human.instances.must_equal [ @joe, @dick, i ]
+        end
+      end
+
+      describe ".forget_all_instances" do
+        it "should unregister all instances" do
+          @saint.forget_all_instances
+          @human.instances.must_equal [ @joe ]
+          @human.forget_all_instances
+          @human.instances.must_equal []
+        end
       end
-      name
     end
-    @ç.name_get_hook do |name_object|
-      @reporter.define_singleton_method :name_get do
-        "Name get hook called on #{name_object}"
+
+    describe ".new with :name/:ɴ parameters supplied" do
+      it "should work" do
+        c = @c.call
+        i1 = c.new name: :Fred
+        i1.name.must_equal :Fred
+        i2 = c.new name: "Joe"
+        i2.name.must_equal :Joe
       end
-      name_object
+    end
+
+    describe ".new with name!: parameter supplied" do
+      it "must steal names of other instances" do
+        c = @c.call
+        i1 = c.new name: "Joe"
+        i1.name.must_equal :Joe
+        -> { c.new name: "Joe" }.must_raise NameError
+        i2 = c.new name!: "Joe"
+        i2.name.must_equal :Joe
+        i1.name.must_equal nil
+        -> { c.new name: "Joe", name!: "Joe" }
+          .must_raise ArgumentError
+        -> { c.new name!: "Joe", avid: nil }
+          .must_raise ArgumentError
+      end
+    end
+  end # describe NameMagic::ClassMethods
+
+  describe ".instantiation_exec hook" do
+    it "must execute upon instantiation" do
+      c = @c.call
+      object_ids = []
+      c.instantiation_exec do |instance|
+        object_ids << instance.object_id
+      end
+      i1 = c.new
+      object_ids.size.must_equal 1
+      i2 = c.new
+      object_ids.size.must_equal 2
+      object_ids.must_equal [ i1.object_id, i2.object_id ]
+    end
+
+    it "must run in the context of the instance's class" do
+      c = @c.call
+      c.instantiation_exec do foobar() end
+      flag = false
+      -> { c.new }.must_raise NoMethodError
+      flag.must_equal false
+      c.define_singleton_method :foobar do flag = true end
+      c.new
+      flag.must_equal true
     end
   end
-  
-  it "should work" do
-    @ç.must_respond_to :const_magic
-    @ç.instances.must_be_empty
-    @ç.nameless_instances.must_be_empty
-    @reporter.report.must_equal nil
-    x = @ç.new( name: "Boris" )
-    @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 hook called on Boris"
-    ufo = @ç.new
-    @ç.nameless_instances.must_equal [ufo]
-    UFO = @ç.new
-    @reporter.report.must_equal "Instance reported"
-    @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 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
-    Rover.name.must_equal :Rover
-    XXX::Rover.must_be_kind_of @ç
-    @ç.namespace!
-    Spot = @ç.new
-    @ç.const_magic
-    Spot.name.must_equal :Spot
-    -> { XXX::Spot }.must_raise NameError
-    @ç.const_get( :Spot ).must_be_kind_of @ç
-    # Array
-    [ Spot ].names.must_equal [ :Spot ]
-    { Spot => 42 }.keys_to_names.must_equal( { Spot: 42 } )
+
+  describe ".exec_when_naming hook" do
+    it "must execute just before naming and allow censorship" do
+      c = @c.call
+      baptised_instances = []
+      discarded_names = []
+      c.exec_when_naming do |name, instance, old_name|
+        baptised_instances << instance
+        discarded_names << old_name if old_name
+        # Censor the name.
+        name.end_with?( "gnucius" ) ? "St_IGNUcius" : name
+      end
+      c.new name: :Joe
+      c.new name: :Dave
+      baptised_instances
+        .must_equal [ c.instance( :Joe ), c.instance( :Dave ) ]
+      discarded_names.must_equal []
+      c.instance( :Dave ).name = "Ignucius"
+      baptised_instances.names
+        .must_equal [ :Joe, :St_IGNUcius, :St_IGNUcius ]
+      discarded_names.must_equal [ :Dave ]
+    end
+
+    it "must execute in the context of the instance's class" do
+      c = @c.call
+      i = c.new
+      c.define_singleton_method :foobar do "Foobar" end
+      c.exec_when_naming do foobar end
+      i.name = :Dave
+      i.name.must_equal :Foobar
+    end
   end
-end    
+
+  describe NameMagic::Namespace do
+    before do
+      @human = @c.call
+      @saint = Class.new @human
+      @ns = Module.new
+      @human.namespace = @ns
+    end
+
+    it "should carry certain instance methods" do
+      [ :instances,
+        :__instances__,
+        :__avid_instances__,
+        :instance,
+        :const_magic,
+        :nameless_instances,
+        :forget,
+        :__forget__,
+        :forget_nameless_instances,
+        :forget_all_instances,
+        :instantiation_exec,
+        :exec_when_naming,
+        :validate_name
+      ].each { |ß|
+        NameMagic::Namespace.instance_methods.must_include ß
+      }
+      NameMagic::Namespace.private_instance_methods
+        .must_include :search_all_modules
+    end
+
+    describe "Namespace#instances" do
+      it "should work as expected" do
+        @ns.instances.must_equal []
+        @saint.new
+        @ns.instances.size.must_equal 1
+      end
+    end
+
+    describe "Namespace#__instances__" do
+      it "should work as expected" do
+        @ns.__instances__.must_equal( {} )
+        @saint.new
+        @ns.__instances__.size.must_equal 1
+      end
+    end
+
+    describe "Namespace#__avid_instances__" do
+      it "should work as expected" do
+        @ns.__avid_instances__.must_equal []
+        @saint.new
+        @ns.__avid_instances__.size.must_equal 1
+      end
+    end
+
+    describe "Namespace#instance" do
+      it "should work as expected" do
+        -> { @ns.instance( :foo ) }.must_raise NameError
+        @saint.new name: :Dave
+        @ns.instance( :Dave ).must_be_kind_of @saint
+      end
+    end
+
+    describe "Namespace#const_magic" do
+      it "should manually trigger constant magic" do
+        registry = @ns.__instances__
+        registry.size.must_equal 0
+        m = Module.new
+        # New instance is assigned to the constant "Dave", but
+        # Namespace#const_magic is not triggered automatically.
+        m::Dave = @saint.new
+        registry.size.must_equal 1
+        instance, name = registry.to_a.first
+        assert name.nil?
+        # Up until this point, #const_magic was not triggered,
+        # because no methods triggering it were invoked. In
+        # everyday use of NameMagic, this rarely happens, but
+        # should it ever happen, we can trigger #const_magic
+        # manually:
+        @ns.const_magic
+        # Now the instance already knows its name:
+        instance, name = registry.to_a.first
+        name.must_equal :Dave
+      end
+    end
+
+    describe "Namespace#nameless_instances" do
+      it "should work as expected" do
+        @ns.nameless_instances.must_equal []
+        @human.new
+        @ns.nameless_instances.size.must_equal 1
+        @ns.instances.first.name = "Fred"
+        @ns.nameless_instances.must_equal []
+      end
+    end
+
+    describe "Namespace#forget" do
+      it "should work as expected" do
+        i = @human.new name: :Fred
+        @ns.instances.size.must_equal 1
+        @ns.forget :Fred
+        @ns.instances.size.must_equal 0
+      end
+    end
+
+    describe "Namespace#__forget__" do
+      it "should work as expected" do
+        i = @human.new name: :Fred
+        @ns.instances.size.must_equal 1
+        @ns.__forget__( :Fred ).must_equal false
+        @ns.instances.size.must_equal 1
+        @ns.__forget__( i ).must_equal :Fred
+        @ns.instances.size.must_equal 0
+      end
+    end
+
+    describe "Namespace#forget_nameless_instances" do
+      it "should work as expected" do
+        i = @saint.new ɴ: "Dave"
+        j = @saint.new
+        @ns.instances.size.must_equal 2
+        @ns.forget_nameless_instances
+        @ns.instances.must_equal [ i ]
+      end
+    end
+
+    describe "Namespace#forget_all_instances" do
+      it "should work as expected" do
+        @saint.new ɴ: "Dave"
+        @ns.instances.size.must_equal 1
+        @ns.forget_all_instances
+        @ns.instances.must_equal []
+      end
+    end
+
+    describe "Namespace#instantiation_exec hook" do
+      it "should work as expected" do
+        flag = false
+        @ns.instantiation_exec do flag = true end
+        @saint.new
+        assert flag
+      end
+    end
+
+    describe "Namespace#exec_when_naming hook" do
+      it "should work as expected" do
+        flag = false
+        @ns.exec_when_naming do |name, _, _| flag = true; name end
+        @saint.new
+        refute flag
+        @ns.instances.first.name = :Dave
+        assert flag
+      end
+    end
+
+    describe "Namespace#validate_name" do
+      it "should work as expected" do
+        @ns.validate_name( :Dave ).must_equal :Dave
+      end
+    end
+  end # describe NameMagic::Namespace
+
+  describe "NameMagic instance methods" do
+    before do
+      @human = @c.call
+      @anon = @human.new
+      @m = Module.new
+      @m::Foo = Module.new
+      @m::Foo::Frank = @human.new
+    end
+
+    describe "#_name_" do
+      it "should return demodulized name of the instance" do
+        @m::Foo::Frank._name_.must_equal :Frank
+        @anon._name_.must_equal nil
+      end
+    end
+
+    describe "#full_name" do
+      it "should return full name of the instance" do
+        skip
+        # FIXME: The test below is purposely wrong.
+        @m::Foo::Frank.full_name.must_equal "@m::Foo::Frank"
+      end
+    end
+
+    describe "#__name__" do
+      it "returns full name without triggering #const_magic" do
+        @m::Foo::Frank.__name__.must_equal nil
+        # Now trigger #const_magic manually.
+        @human.const_magic
+        @m::Foo::Frank.__name__.must_equal :Frank
+      end
+    end
+
+    describe "#name=" do
+      it "names the instance" do
+        @m::Foo::Frank.name.must_equal :Frank
+        @m::Foo::Frank.name = :Joe
+        @m::Foo::Frank.name.must_equal :Joe
+      end
+    end
+
+    describe "#name!" do
+      it "names the instance aggresively" do
+        @m::Foo::Frank.name.must_equal :Frank
+        i = @human.new
+        -> { i.name = :Frank }.must_raise NameError
+        i.name! :Frank
+        i.name.must_equal :Frank
+        @m::Foo::Frank.name.must_equal nil
+      end
+    end
+
+    describe "#avid?" do
+      it "informes whether the instance is avid" do
+        # Avid instance is an unnamed instance that is willing
+        # to accept name even if this already belongs to another
+        # instance, unregistering the conflicter in the process.
+        assert @anon.avid?
+        @anon.name! :Fred
+        refute @anon.avid?
+      end
+    end
+
+    describe "#make_avid!" do
+      it "is a private method that makes the instance avid" do
+        @anon.name = :Fred
+        @anon.unname!
+        -> { @anon.make_avid! }.must_raise NoMethodError
+        @anon.send :make_avid!
+        assert @anon.avid?
+      end
+    end
+
+    describe "#make_not_avid!" do
+      it "removes the avid state from the instance" do
+        assert @anon.avid?
+        @anon.make_not_avid!
+        refute @anon.avid?
+      end
+    end
+
+    describe "NameMagic#exec_when_named hook" do
+      it "is executed just after instance naming" do
+        i = @human.new
+        names = []
+        i.exec_when_named do names << name end
+        names.must_equal []
+        i.name = :Fred
+        names.must_equal [:Fred]
+        j = @human.new
+        names.must_equal [:Fred]
+        j.name = :Joe
+        names.must_equal [:Fred]
+        # Finally, one more way how to use this hook.
+        @human.instantiation_exec do |instance|
+          instance.exec_when_named do names << name end
+        end
+        @human.new name: :Dave
+        names.must_equal [:Fred, :Dave]
+        @human.new name: :St_IGNUcius
+        names.must_equal [:Fred, :Dave, :St_IGNUcius]
+      end
+
+      it "is executed in the context of the instance" do
+        i = @human.new
+        i.define_singleton_method :hello do "hello" end
+        result = nil
+        i.exec_when_named do result = hello, name end
+        i.name = :Dave
+        result.join( ' ' ).must_equal "hello Dave"
+        # Explanation: If the block was not executed in the
+        # context of instance i, method hello wouldn't work.
+      end
+    end
+
+    describe "NameMagic#to_s" do
+      it "is defined to show names of named instances" do
+        @m::Foo::Frank.to_s.must_equal "Frank"
+      end
+    end
+
+    describe "NameMagic#inspect" do
+      it "must show name for named instances" do
+        @m::Foo::Frank.inspect.must_equal "Frank"
+      end
+    end
+  end # describe "NameMagic instance methods"
+
+  describe NameMagic::ArrayMethods do
+    before do
+      c = @c.call
+      @e1 = c.new name: :Fred
+      @e2 = c.new name: :Joe
+      @e3 = c.new
+      @e4 = c.new name: :Julia
+      @a = @e1, @e2, @e3, @e4
+    end
+
+    describe "Array#names" do
+      it "maps unnamed objects into nil by default" do
+        @a.names.must_equal [ :Fred, :Joe, nil, :Julia ]
+        @a.names( nil ).must_equal [ :Fred, :Joe, nil, :Julia ]
+      end
+
+      it "maps unnamed objects into themselves if option=true" do
+        @a.names( true ).must_equal [ :Fred, :Joe, @e3, :Julia ]
+      end
+
+      it "omits the unnamed instances if option=false" do
+        @a.names( false ).must_equal [ :Fred, :Joe, :Julia ]
+      end
+    end
+
+    describe "Array#_names_" do
+      it "maps unnamed objects into nil by default" do
+        @a._names_.must_equal [ :Fred, :Joe, nil, :Julia ]
+        @a._names_( nil ).must_equal [ :Fred, :Joe, nil, :Julia ]
+      end
+
+      it "maps unnamed objects into themselves if option=true" do
+        @a._names_( true ).must_equal [ :Fred, :Joe, @e3, :Julia ]
+      end
+
+      it "omits the unnamed instances if option=false" do
+        @a._names_( false ).must_equal [ :Fred, :Joe, :Julia ]
+      end
+    end
+  end
+
+  describe NameMagic::HashMethods do
+    before do
+      c = @c.call
+      @i, @j = c.new( name: :Fred ), c.new( name: :Joe )
+    end
+
+    describe "Hash#keys_to_names" do
+      # TODO: Consider method to keys_to_full_names.
+      it "must work as expected" do
+        { @i => 1, @j => 2 }.keys_to_names
+          .must_equal( { Fred: 1, Joe: 2 } )
+      end
+    end
+
+    describe "Hash#keys_to_names!" do
+      it "must work as expected" do
+        h = { @i => 1, @j => 2 }
+        h.keys_to_names!
+        h.must_equal( { Fred: 1, Joe: 2 } )
+      end
+    end
+
+    describe "Hash#keys_to_ɴ" do
+      it "must work as expected" do
+        { @i => 1, @j => 2 }.keys_to_ɴ
+          .must_equal( { Fred: 1, Joe: 2 } )
+      end
+    end
+
+    describe "Hash#keys_to_ɴ!" do
+      it "must work as expected" do
+        h = { @i => 1, @j => 2 }
+        h.keys_to_ɴ!
+        h.must_equal( { Fred: 1, Joe: 2 } )
+      end
+    end
+  end
+
+  describe "renaming" do
+    before do
+      @human = @c.call
+      @city = Module.new
+      @human.namespace = @city
+    end
+
+    it "is possible without restrictions" do
+      a = @human.new name: :Fred
+      a.name.must_equal :Fred
+      # Fred can be renamed to Joe without problems.
+      a.name = :Joe
+      a.name.must_equal :Joe
+    end
+
+    it "can be prohibited eg. by naming hook" do
+      @city.exec_when_naming do |name, instance, old_name|
+        fail NameError, "Renaming is now prohibited!" if old_name
+        name
+      end
+      a = @human.new name: :Fred
+      -> { a.name = :Joe }.must_raise NameError
+    end
+  end
+
+  describe "name collisions" do
+    before do
+      @human = @c.call
+      @city = Module.new
+      @human.namespace = @city
+      @a = @human.new name: :Fred
+    end
+
+    it "cannot construct another Fred by #new method" do
+      -> { @human.new name: :Fred }.must_raise NameError
+    end
+
+    it "cannot construct another Fred by #name= method" do
+      b = @human.new
+      -> { b.name = :Fred }.must_raise NameError
+    end
+
+    it "can, however, steal name Fred by constant assignment" do
+      m = Module.new
+      m::Fred = @human.new
+    end
+  end
+
+  describe "how avid instances work" do
+    describe "why avidity is needed" do
+      # In NameMagic, names are unique. At the same time, naming
+      # can be performed by constant assignment. If all instances
+      # were always avid, fights over a name would ensue if two
+      # constant assignments leading to the same naming were
+      # present in the namespace. We could get rid of avidity
+      # only if the naming was done using constant names with
+      # full Ruby namespace path. The question is, should we do
+      # this? It would surely break some dependencies. I am not
+      # gonna do it until YPetri paper is out. However, I feel
+      # that naming by full namespace path of the constant will
+      # be a must if I try to make use of the Ruby's native
+      # namespace mechanism for YPetri / YNelson nets and for
+      # YChem / YCell modules.
+    end
+
+    describe "new instance" do
+      before do
+        @test_class = @c.call
+        @test_instance = @test_class.new
+      end
+
+      it "is created avid" do
+        assert @test_instance.avid?
+      end
+
+      it "can lose its avidity using #make_not_avid! method" do
+        @test_instance.make_not_avid!
+        refute @test_instance.avid?
+      end
+
+      it "also loses avidity by naming" do
+        @test_instance.name = :Joe
+        refute @test_instance.avid?
+      end
+    end
+
+    describe "unnamed instance" do
+      before do
+        @test_class = @c.call
+        @test_instance = @test_class.new
+      end
+
+      it "does not regain avidity it lost upon naming" do
+        assert @test_instance.avid?
+        @test_instance.name = :Jane
+        refute @test_instance.avid?
+        @test_instance.unname!.must_equal :Jane
+        refute @test_instance.avid?
+      end
+
+      it "does not raise repeated NameError if it is assigned" +
+         "to some forgotten constant in the namespace" do
+        m, n = Module.new, Module.new
+        i, j = @test_class.new, @test_class.new
+        m::Jane = i
+        assert i.name == :Jane
+        n::Jane = j
+        assert i.name == nil
+        assert j.name == :Jane
+        i.send :make_avid!
+        assert i.avid?
+        assert i.name == :Jane
+        assert j.name == nil
+        refute i.avid?
+        refute j.avid?
+      end
+    end
+  end
+
+  describe "unnaming" do
+    before do
+      @test_class = @c.call
+      @test_instance = @test_class.new
+    end
+
+    describe "NameMagic#unname!" do
+      it "unnames the instance if unnaming is allowed" do
+        @test_instance.name = :Fred
+        @test_instance.unname!.must_equal :Fred
+        assert @test_instance.name.nil?
+      end
+    end
+
+    describe "NameMagic#unnaming_allowed?" do
+      it "depends on #permanent_names? method" do
+        assert @test_instance.unnaming_allowed?
+        @test_class.class_exec { permanent_names! }
+        refute @test_instance.unnaming_allowed?
+      end
+    end
+
+    describe "NameMagic#exec_when_unnamed" do
+      it "executes upon unnaming" do
+        reporter = []
+        @test_instance.exec_when_unnamed { reporter << object_id }
+        @test_instance.unname!
+        # The instance was anonymous to begin with, so no unnaming
+        # took place. Therefore, no change to the reporter.
+        reporter.must_equal []
+        @test_instance.name = :Fred
+        reporter.must_equal []
+        @test_instance.unname!
+        # Block was called only after the unnaming has happened.
+        reporter.must_equal [ @test_instance.object_id ]
+        @test_instance.name = :Fred
+        another_instance = @test_class.new
+        m = Module.new
+        # Here, unnaming of the former Fred should take place.
+        m::Fred = another_instance
+        # We have to invoke const_magic manually.
+        @test_class.const_magic
+        reporter.must_equal [ @test_instance.object_id ] * 2
+      end
+    end
+
+    describe "NameMagic::ClassMethods#exec_when_unnaming" do
+      it "executes just before unnaming the instance" do
+        reporter = []
+        @test_class.exec_when_unnaming do
+          reporter = instances.names
+        end
+        @test_instance.unname!.must_equal nil
+        reporter.must_equal []
+        @test_instance.name = :Fred
+        @test_instance.unname!.must_equal :Fred
+        reporter.must_equal [ :Fred ]
+        @test_class.instances.names.must_equal [ nil ]
+      end
+    end
+
+    describe "NameMagic::Namespace#exec_when_unnaming" do
+      it "executes just before unnaming the instance" do
+        m = Module.new
+        c = @c.call
+        c.namespace = m
+        reporter = []
+        m.exec_when_unnaming do |instance, former_name|
+          reporter << instance
+          reporter << former_name
+        end
+        i = c.new name: :Fred
+        j = c.new name!: :Fred
+        j.name.must_equal :Fred
+        i.name.must_equal nil
+        reporter.must_equal [ i, :Fred ]
+      end
+    end
+
+    describe "NameMagic::ClassMethods#permanent_names?" do
+      it "is selector of @permanent_names attribute" do
+        refute @test_class.permanent_names?
+        @test_class.class_exec { permanent_names! }
+        assert @test_class.permanent_names?
+      end
+    end
+
+    describe "NameMagic::ClassMethods#permanent_names!" do
+      it "should prohibit unnaming of the instances" do
+        c = @c.call
+        i = c.new name: :Fred
+        i.name.must_equal :Fred
+        i.unname!.must_equal :Fred
+        i.name = :Fred
+        c.instance_exec { permanent_names! }
+        -> { i.unname! }.must_raise NameError
+      end
+    end
+
+    describe "NameMagic::Namespace#permanent_names? and" +
+             "NameMagic::Namespace#permanent_names!" do
+      it "is selector of @permanent_names attribute" do
+        m = Module.new
+        c = @c.call
+        c.namespace = m
+        c.permanent_names!
+        assert m.permanent_names?
+        n = Module.new
+        c.namespace = n
+        # Shifting to a brand new namespace means that
+        # @permanent_names attribute will be reset to nil again.
+        # Fortunately, such operation is possible only when the
+        # instance registry is empty.
+        refute c.permanent_names?
+        refute n.permanent_names?
+        n.permanent_names!
+        assert c.permanent_names?
+        assert n.permanent_names?
+      end
+    end
+  end
+
+  describe "how NameMagic can be included modules and classes" do
+    it "can be included directly" do
+      c = Class.new do include NameMagic end
+      i = c.new name: :Jane
+      c.instances.names.must_equal [ :Jane ]
+    end
+
+    it "can be included in a module first, which can be " +
+       "included in another module, and so on, until it is " +
+       "included in a class, which can be subclassed, and " +
+       "subclassed again, and it will still work as expected" do
+      m1 = Module.new do include NameMagic end
+      m2 = Module.new do include m1 end
+      m3 = Module.new do include m2 end
+      animal = Class.new do include m3 end
+      mammal = Class.new animal
+      human = Class.new mammal
+      animal.instances.must_equal []
+      human.new name!: :Jane
+      animal.instances.names.must_equal [ :Jane ]
+      mammal.new name: :Spot
+      animal.instances.names.must_equal [ :Jane, :Spot ]
+      mammal.instances.names.must_equal [ :Jane, :Spot ]
+      human.instances.names.must_equal [ :Jane ]
+   end
+end
+end # describe NameMagic