nannified

Demo/metaclasses/Eiffel.py

@@ -4,19 +4,19 @@ For example,
 
 class C:
     def m1(self, arg):
-	require arg > 0
-	return whatever
+        require arg > 0
+        return whatever
         ensure Result > arg
 
 can be written (clumsily, I agree) as:
 
 class C(Eiffel):
     def m1(self, arg):
-	return whatever
+        return whatever
     def m1_pre(self, arg):
-	assert arg > 0
+        assert arg > 0
     def m1_post(self, Result, arg):
-	assert Result > arg
+        assert Result > arg
 
 Pre- and post-conditions for a method, being implemented as methods
 themselves, are inherited independently from the method.  This gives
@@ -28,10 +28,10 @@ post-condition with that defined in the derived class', for example:
 
 class D(C):
     def m1(self, arg):
-	return whatever**2
+        return whatever**2
     def m1_post(self, Result, arg):
-	C.m1_post(self, Result, arg)
-	assert Result < 100
+        C.m1_post(self, Result, arg)
+        assert Result < 100
 
 This gives derived classes more freedom but also more responsibility
 than in Eiffel, where the compiler automatically takes care of this.
@@ -42,13 +42,13 @@ up to the derived class.  For example, a derived class that takes away
 the requirement that arg > 0 could write:
 
     def m1_pre(self, arg):
-	pass
+        pass
 
 but one could equally write a derived class that makes a stronger
 requirement:
 
     def m1_pre(self, arg):
-	require arg > 50
+        require arg > 50
 
 It would be easy to modify the classes shown here so that pre- and
 post-conditions can be disabled (separately, on a per-class basis).
@@ -66,27 +66,27 @@ from Meta import MetaClass, MetaHelper, MetaMethodWrapper
 class EiffelMethodWrapper(MetaMethodWrapper):
 
     def __init__(self, func, inst):
-	MetaMethodWrapper.__init__(self, func, inst)
-	# Note that the following causes recursive wrappers around
-	# the pre-/post-condition testing methods.  These are harmless
-	# but inefficient; to avoid them, the lookup must be done
-	# using the class.
-	try:
-	    self.pre = getattr(inst, self.__name__ + "_pre")
-	except AttributeError:
-	    self.pre = None
-	try:
-	    self.post = getattr(inst, self.__name__ + "_post")
-	except AttributeError:
-	    self.post = None
+        MetaMethodWrapper.__init__(self, func, inst)
+        # Note that the following causes recursive wrappers around
+        # the pre-/post-condition testing methods.  These are harmless
+        # but inefficient; to avoid them, the lookup must be done
+        # using the class.
+        try:
+            self.pre = getattr(inst, self.__name__ + "_pre")
+        except AttributeError:
+            self.pre = None
+        try:
+            self.post = getattr(inst, self.__name__ + "_post")
+        except AttributeError:
+            self.post = None
 
     def __call__(self, *args, **kw):
-	if self.pre:
-	    apply(self.pre, args, kw)
-	Result = apply(self.func, (self.inst,) + args, kw)
-	if self.post:
-	    apply(self.post, (Result,) + args, kw)
-	return Result
+        if self.pre:
+            apply(self.pre, args, kw)
+        Result = apply(self.func, (self.inst,) + args, kw)
+        if self.post:
+            apply(self.post, (Result,) + args, kw)
+        return Result
     
 class EiffelHelper(MetaHelper):
     __methodwrapper__ = EiffelMethodWrapper
@@ -99,12 +99,12 @@ Eiffel = EiffelMetaClass('Eiffel', (), {})
 
 def _test():
     class C(Eiffel):
-	def m1(self, arg):
-	    return arg+1
-	def m1_pre(self, arg):
-	    assert arg > 0, "precondition for m1 failed"
-	def m1_post(self, Result, arg):
-	    assert Result > arg
+        def m1(self, arg):
+            return arg+1
+        def m1_pre(self, arg):
+            assert arg > 0, "precondition for m1 failed"
+        def m1_post(self, Result, arg):
+            assert Result > arg
     x = C()
     x.m1(12)
 ##    x.m1(-1)