Indent test cases in cacher.py.
authorNeil Moore <neil@s-z.org>
Wed, 28 May 2008 03:07:58 +0000 (23:07 -0400)
committerNeil Moore <neil@s-z.org>
Wed, 28 May 2008 03:07:58 +0000 (23:07 -0400)
cacher.py

index aec4e97..06b9a96 100644 (file)
--- a/cacher.py
+++ b/cacher.py
@@ -2,97 +2,81 @@ class FirstArg(type):
     """Metaclass to cache object creation by a key, which must be the
     first constructor parameter.
     
-    >>> import cacher
-    >>> class MyClass (object):
-    ...     __metaclass__ = cacher.FirstArg
-    ...     def __init__(self, name, extra):
-    ...         self.name = name
-    ...         self.extra = extra
-    >>> obj = MyClass('foo', 42)
-
+        >>> import cacher
+        >>> class MyClass (object):
+        ...     __metaclass__ = cacher.FirstArg
+        ...     def __init__(self, name, extra):
+        ...         self.name = name
+        ...         self.extra = extra
+        >>> obj = MyClass('foo', 42)
 
     The constructor must be called with the correct number of arguments:
+        >>> bad = MyClass('bad')
+        Traceback (most recent call last):
+            ....
+        TypeError: __init__() takes exactly 3 arguments (2 given)
 
-    >>> bad = MyClass('bad')
-    Traceback (most recent call last):
-        ....
-    TypeError: __init__() takes exactly 3 arguments (2 given)
-
-
-    Subsequent calls to the constructor that have the same first argument
-    yield the same object:
-
-    >>> MyClass('foo', 42) is obj
-    True
+    Subsequent calls to the constructor with the same first argument result
+    in the same object:
+        >>> MyClass('foo', 42) is obj
+        True
 
     
     This is true even if the other parameters differ:
-
-    >>> MyClass('foo', None) is obj
-    True
-    >>> MyClass('foo', 'twelve').extra
-    42
-
-
-    In fact, if an instance has been constructed, the remaining
-    parameters are disregarded, and can be omitted:
-
-    >>> MyClass('foo') is obj
-    True
-    >>> MyClass('foo', 1, 2, 3, 4, 5, 6, 7) is obj
-    True
-
+        >>> MyClass('foo', None) is obj
+        True
+        >>> MyClass('foo', 'twelve').extra
+        42
+
+    In fact, if an instance has already been constructed, the remaining
+    parameters are disregarded entirely, and may be omitted:
+        >>> MyClass('foo') is obj
+        True
+        >>> MyClass('foo', 1, 2, 3, 4, 5, 6, 7) is obj
+        True
 
     If the first parameter differs, the constructed object will differ:
-
-    >>> MyClass('bar', 18) is obj
-    False
-    >>> MyClass('bar').extra
-    18
-
+        >>> MyClass('bar', 18) is obj
+        False
+        >>> MyClass('bar').extra
+        18
 
     Any immutable key may be used:
-
-    >>> pairobj = MyClass((1,2), {})
-    >>> MyClass((1,2)).name
-    (1, 2)
-    >>> MyClass((1,2)).extra
-    {}
-    >>> badobj = MyClass([1,2], 26)
-    Traceback (most recent call last):
-        ....
-    TypeError: list objects are unhashable
-
+        >>> pairobj = MyClass((1,2), {})
+        >>> MyClass((1,2)).name
+        (1, 2)
+        >>> MyClass((1,2)).extra
+        {}
+        >>> badobj = MyClass([1,2], 26)
+        Traceback (most recent call last):
+            ....
+        TypeError: list objects are unhashable
 
     However, the key None will not be cached:
+        >>> noneobj = ( MyClass(None, 'first'), MyClass(None, 'second') )
+        >>> noneobj[0].extra
+        'first'
+        >>> noneobj[1].extra
+        'second'
 
-    >>> noneobj = ( MyClass(None, 'first'), MyClass(None, 'second') )
-    >>> noneobj[0].extra
-    'first'
-    >>> noneobj[1].extra
-    'second'
-
-   
     The objects themselves can be mutable:
-
-    >>> MyClass('foo').extra = 9
-    >>> obj.extra
-    9
-    >>> MyClass('bar').name = 'something else'
-    >>> MyClass('bar').name
-    'something else'
+        >>> MyClass('foo').extra = 9
+        >>> obj.extra
+        9
+        >>> MyClass('bar').name = 'something else'
+        >>> MyClass('bar').name
+        'something else'
 
     
     The cache is not shared with subclasses:
-
-    >>> class SubClass (MyClass):
-    ...     def __init__(self, name, extra):
-    ...         super(SubClass,self).__init__(name, extra)
-    >>> sub = SubClass('foo', 76)
-    >>> sub is obj
-    False
-    >>> sub.extra
-    76
+        >>> class SubClass (MyClass):
+        ...     def __init__(self, name, extra):
+        ...         super(SubClass,self).__init__(name, extra)
+        >>> sub = SubClass('foo', 76)
+        >>> sub is obj
+        False
+        >>> sub.extra
+        76
     """
     def __init__(cls, name, bases, cdict):
         super(FirstArg, cls).__init__(name, bases, cdict)
@@ -107,65 +91,54 @@ class FirstArg(type):
 class Singleton (type):
     """Metaclass for singleton objects.  After the first constructor call
     initializes an object, subsequent calls will return the same object.
-    
-    >>> import cacher
-    >>> class MyClass (object):
-    ...     __metaclass__ = cacher.Singleton
-    ...     def __init__(self, data):
-    ...         self.data = data
-
+        >>> import cacher
+        >>> class MyClass (object):
+        ...     __metaclass__ = cacher.Singleton
+        ...     def __init__(self, data):
+        ...         self.data = data
 
     The constructor must be called with the correct number of arguments:
-
-    >>> bad = MyClass()
-    Traceback (most recent call last):
-        ....
-    TypeError: __init__() takes exactly 2 arguments (1 given)
-    >>> obj = MyClass('only')
-
+        >>> bad = MyClass()
+        Traceback (most recent call last):
+            ....
+        TypeError: __init__() takes exactly 2 arguments (1 given)
+        >>> obj = MyClass('only')
 
     After an object is successfully constructed, subsequent calls to the
     constructor yield the same object:
-
-    >>> MyClass('only') is obj
-    True
+        >>> MyClass('only') is obj
+        True
 
     
     This is true even if the other parameters differ:
-
-    >>> MyClass('another') is obj
-    True
-    >>> MyClass('ignored').data
-    'only'
-
+        >>> MyClass('another') is obj
+        True
+        >>> MyClass('ignored').data
+        'only'
 
     In fact, once an instance has been constructed, subsequent calls to
-    the constructor ignore their parameters:
-
-    >>> MyClass() is obj
-    True
-    >>> MyClass(1, 2, 3, 4, 5, 6, 7) is obj
-    True
+    the constructor ignore the parameters entirely:
+        >>> MyClass() is obj
+        True
+        >>> MyClass(1, 2, 3, 4, 5, 6, 7) is obj
+        True
     
     The objects can be mutable:
-
-    >>> MyClass().data = 'changed'
-    >>> obj.data
-    'changed'
-
+        >>> MyClass().data = 'changed'
+        >>> obj.data
+        'changed'
     
     The cache is not shared with subclasses:
-
-    >>> class SubClass (MyClass):
-    ...     def __init__(self, data):
-    ...         super(SubClass,self).__init__(data)
-    >>> sub = SubClass('foo')
-    >>> sub is obj
-    False
-    >>> sub.data
-    'foo'
-    >>> MyClass('foo').data
-    'changed'
+        >>> class SubClass (MyClass):
+        ...     def __init__(self, data):
+        ...         super(SubClass,self).__init__(data)
+        >>> sub = SubClass('foo')
+        >>> sub is obj
+        False
+        >>> sub.data
+        'foo'
+        >>> MyClass('foo').data
+        'changed'
     """
     def __init__(cls, name, bases, cdict):
         super(Singleton, cls).__init__(name, bases, cdict)