Improvements to component.py.

Components are now based fully on traitlets.  The have a better
querying interface and smart children, parent, root properties.

Some testing has been added.

IPython/core/component.py

@@ -23,9 +23,9 b' Authors:'
 
 from weakref import WeakValueDictionary
 
+from IPython.utils.ipstruct import Struct
 from IPython.utils.traitlets import (
-    HasTraitlets, TraitletError, MetaHasTraitlets,
-    Int, Float, Str, Bool, Unicode
+    HasTraitlets, TraitletError, MetaHasTraitlets, Instance, This
 )
 
 
@@ -34,10 +34,6 b' from IPython.utils.traitlets import ('
 #-----------------------------------------------------------------------------
 
 
-class Config(object):
-    pass
-
-
 class MetaComponentTracker(type):
     """A metaclass that tracks instances of Components and its subclasses."""
 
@@ -47,9 +43,9 b' class MetaComponentTracker(type):'
         cls.__numcreated = 0
 
     def __call__(cls, *args, **kw):
-        """Called when class is called (instantiated)!!!
+        """Called when *class* is called (instantiated)!!!
         
-        Then a Component or subclass is instantiated, this is called and
+        When a Component or subclass is instantiated, this is called and
         the instance is saved in a WeakValueDictionary for tracking.
         """
 
@@ -60,32 +56,34 b' class MetaComponentTracker(type):'
                 c.__instance_refs[c.__numcreated] = instance
         return instance
 
-    def get_instances(cls):
-        """Get all instances of cls and its subclasses."""
-        return cls.__instance_refs.values()
-
-    def get_instances_by_name(cls, name):
-        """Get all instances of cls and its subclasses by name."""
-        return [i for i in cls.get_instances() if i.name == name]
-
-    def get_instances_by_subclass(cls, thisclass):
-        """Get all instances of cls that are instances of thisclass.
+    def get_instances(cls, name=None, klass=None, root=None):
+        """Get all instances of cls and its subclasses.
         
-        This includes all instances of subclasses of thisclass.
+        Parameters
+        ----------
+        name : str
+            Limit to components with this name.
+        klass : class
+            Limit to components having isinstance(component, klass)
+        root : Component or subclass
+            Limit to components having this root.
         """
-        return [i for i in cls.get_instances() if isinstance(i, thisclass)]
-
-    def get_instances_by_class(cls, thisclass):
-        """Get all instances of cls that are instances of thisclass.
-        
-        This exclused instances of thisclass subclasses.
+        instances = cls.__instance_refs.values()
+        if name is not None:
+            instances = [i for i in instances if i.name == name]
+        if klass is not None:
+            instances = [i for i in instances if isinstance(i, klass)]
+        if root is not None:
+            instances = [i for i in instances if i.root == root]
+        return instances
+
+    def get_instances_by_condition(cls, call, name=None, klass=None, root=None):
+        """Get all instances of cls, i such that call(i)==True.
+
+        This also takes the ``name``, ``klass`` and ``root`` arguments of
+        :meth:`get_instance`
         """
-
-        return [i for i in cls.get_instances() if type(i) is thisclass]
-
-    def get_instances_by_condition(cls, call):
-        """Get all instances of cls, i such that call(i)==True."""
-        return [i for i in cls.get_instances() if call(i)]
+        return [i for i in cls.get_instances(name,klass,root) if call(i)]
 
 
 class ComponentNameGenerator(object):
@@ -117,7 +115,10 b' class Component(HasTraitlets):'
 
     __metaclass__ = MetaComponent
 
-    config = Config()
+    # Traitlets are fun!
+    config = Instance(Struct)
+    parent = This(allow_none=True)
+    root = This(allow_none=True)
 
     def __init__(self, parent, name=None, config=None):
         """Create a component given a parent.
@@ -140,11 +141,13 b' class Component(HasTraitlets):'
             to this argument.  We might think about changing this behavior.
         """
         super(Component, self).__init__()
+        self._children = []
         if name is None:
-            self._name = ComponentNameGenerator()
+            self.name = ComponentNameGenerator()
         else:
-            self._name = name
-        self.parent = parent # this uses the property and handles None
+            self.name = name
+        self.root = self # This is the default, it is set when parent is set
+        self.parent = parent
         if config is not None:
             self.config = config
         else:
@@ -152,33 +155,35 b' class Component(HasTraitlets):'
                 self.config = self.parent.config
 
     #-------------------------------------------------------------------------
-    # Properties
+    # Static traitlet notifiations
     #-------------------------------------------------------------------------
 
-    def _set_name(self, name):
-        # This should use the ComponentNameGenerator to test for uniqueness
-        self._name = name
-
-    def _get_name(self):
-        return self._name
+    def _parent_changed(self, name, old, new):
+        if old is not None:
+            old._remove_child(self)
+        if new is not None:
+            new._add_child(self)
 
-    name = property(_get_name, _set_name)
-
-    def _set_parent(self, parent):
-        if parent is None:
-            self._parent = None
-            self._root = self
+        if new is None:
+            self.root = self
         else:
-            assert isinstance(parent, Component), 'parent must be a component'
-            self._parent = parent
-            self._root = parent.root
-
-    def _get_parent(self):
-        return self._parent
-
-    parent = property(_get_parent, _set_parent)
+            self.root = new.root
 
     @property
-    def root(self):
-        return self._root
-
+    def children(self):
+        """A list of all my child components."""
+        return self._children
+
+    def _remove_child(self, child):
+        """A private method for removing children componenets."""
+        if child in self._children:
+            index = self._children.index(child)
+            del self._children[index]
+
+    def _add_child(self, child):
+        """A private method for adding children componenets."""
+        if child not in self._children:
+            self._children.append(child)
+
+    def __repr__(self):
+        return "<Component('%s')>" % self.name
  No newline at end of file

IPython/utils/tests/test_traitlets.py

@@ -31,7 +31,7 b' from unittest import TestCase'
 from IPython.utils.traitlets import (
     HasTraitlets, MetaHasTraitlets, TraitletType, Any,
     Int, Long, Float, Complex, Str, Unicode, Bool, TraitletError,
-    Undefined, Type, Instance
+    Undefined, Type, Instance, This
 )
 
 
@@ -440,6 +440,44 b' class TestInstance(TestCase):'
         b = B()
         self.assertRaises(TraitletError, getattr, b, 'inst')
 
+
+class TestThis(TestCase):
+
+    def test_this_class(self):
+        class Foo(HasTraitlets):
+            this = This
+
+        f = Foo()
+        self.assertEquals(f.this, None)
+        g = Foo()
+        f.this = g
+        self.assertEquals(f.this, g)
+        self.assertRaises(TraitletError, setattr, f, 'this', 10)
+
+    def test_this_inst(self):
+        class Foo(HasTraitlets):
+            this = This()
+        
+        f = Foo()
+        f.this = Foo()
+        self.assert_(isinstance(f.this, Foo))
+
+    def test_allow_none(self):
+        class Foo(HasTraitlets):
+            this = This(allow_none=False)
+
+        f = Foo()
+        g = Foo()
+        f.this = g
+        self.assertEquals(f.this, g)
+
+        f = Foo()
+        self.assertRaises(TraitletError, getattr, f, 'this')
+
+        f = Foo()
+        self.assertRaises(TraitletError, setattr, f, 'this', None)
+
+
 class TraitletTestBase(TestCase):
     """A best testing class for basic traitlet types."""
 

IPython/utils/traitlets.py

@@ -167,18 +167,23 b' class TraitletType(object):'
         dv = self.default_value
         return dv
 
-    def __get__(self, obj, cls=None):
+    def __get__(self, obj, cls=None, skipset=False):
         """Get the value of the traitlet by self.name for the instance.
         
         The creation of default values is deferred until this is called the
         first time.  This is done so instances of the parent HasTraitlets
         will have their own default value instances.
+
+        A default value is not validated until it is requested.  Thus, if
+        you use an invalid default value, but never request it, you are fine.
         """
         if obj is None:
             return self
         else:
             if not obj._traitlet_values.has_key(self.name):
                 dv = self.get_default_value()
+                # Call __set__ with first=True so we don't get a recursion
+                if not skipset:
                 self.__set__(obj, dv, first=True)
                 return dv
             else:
@@ -187,7 +192,8 b' class TraitletType(object):'
     def __set__(self, obj, value, first=False):
         new_value = self._validate(obj, value)
         if not first:
-            old_value = self.__get__(obj)
+            # Call __get__ with skipset=True so we don't get a recursion
+            old_value = self.__get__(obj, skipset=True)
             if old_value != new_value:
                 obj._traitlet_values[self.name] = new_value
                 obj._notify_traitlet(self.name, old_value, new_value)
@@ -659,6 +665,40 b' class Instance(BaseClassResolver):'
             return dv
 
 
+class This(TraitletType):
+    """A traitlet for instances of the class containing this trait."""
+
+    info_text = 'an instance of the same type as the receiver'
+
+    def __init__(self, default_value=None, allow_none=True, **metadata):
+        if default_value is not None:
+            raise TraitletError("The default value of 'This' can only be None.")
+        super(This, self).__init__(default_value, **metadata)
+        self._allow_none = allow_none
+        if allow_none:
+            self.info_text = self.info_text + ' or None'
+
+    def validate(self, obj, value):
+        if value is None:
+            if self._allow_none:
+                return value
+            self.validate_failed(obj, value)
+
+        if isinstance(value, obj.__class__):
+            return value
+        else:
+            self.validate_failed(obj, value)
+
+    def validate_failed (self, obj, value):
+        kind = type(value)
+        if kind is InstanceType:
+            msg = 'class %s' % value.__class__.__name__
+        else:
+            msg = '%s (i.e. %s)' % ( str( kind )[1:-1], repr( value ) )
+
+        self.error(obj, msg)
+
+
 #-----------------------------------------------------------------------------
 # Basic TraitletTypes implementations/subclasses
 #-----------------------------------------------------------------------------