[Checkins] SVN: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/ tabs -> spaces

[Adam Groszer]

Log message for revision 89434:
  tabs -> spaces

Changed:
  U   Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.txt
  U   Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/algebra.txt

-=-
Modified: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.txt
===================================================================
--- Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.txt	2008-08-06 10:59:25 UTC (rev 89433)
+++ Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/queryobject/queryobject.txt	2008-08-06 10:59:52 UTC (rev 89434)
@@ -9,220 +9,220 @@
 
     >>> from ocql.queryobject.queryobject import *
     >>> from ocql.testing.database import TestMetadata
-	>>> from ocql.parser.newqueryparser import SymbolContainer
+    >>> from ocql.parser.newqueryparser import SymbolContainer
 
     >>> from zope.interface.verify import verifyClass, verifyObject
 
-   	>>> child = Child()
-	>>> metadata = TestMetadata()
-	>>> symbols = SymbolContainer()
+    >>> child = Child()
+    >>> metadata = TestMetadata()
+    >>> symbols = SymbolContainer()
 
     >>> verifyClass(IObjectQueryHead, Head)
     True
-	>>> verifyObject(IObjectQueryHead, Head(child))
-	True
+    >>> verifyObject(IObjectQueryHead, Head(child))
+    True
 
     >>> verifyClass(IObjectQueryChild, Child)
     True
-	>>> verifyObject(IObjectQueryChild, child)
-	True
+    >>> verifyObject(IObjectQueryChild, child)
+    True
 
     >>> verifyClass(IObjectQuery, QueryObject)
     True
-	>>> verifyObject(IObjectQuery, QueryObject(metadata, symbols))
-	True
+    >>> verifyObject(IObjectQuery, QueryObject(metadata, symbols))
+    True
 
     >>> verifyClass(ITerm, Term)
     True
-	>>> verifyObject(ITerm, Term(metadata, symbols, child, child))
-	True
+    >>> verifyObject(ITerm, Term(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IExpression, Expression)
     True
-	>>> verifyObject(IExpression, Expression(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IExpression, Expression(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IhasClassWith, hasClassWith)
     True
-	>>> verifyObject(IhasClassWith, hasClassWith(metadata, symbols, child, set, child))
-	True
+    >>> verifyObject(IhasClassWith, hasClassWith(metadata, symbols, child, set, child))
+    True
 
     >>> verifyClass(IIdentifier, Identifier)
     True
-	>>> verifyObject(IIdentifier, Identifier(metadata, symbols, child))
-	True
+    >>> verifyObject(IIdentifier, Identifier(metadata, symbols, child))
+    True
 
     >>> verifyClass(IConstant, Constant)
     True
-	>>> verifyObject(IConstant, Constant(metadata, symbols, child))
-	True
+    >>> verifyObject(IConstant, Constant(metadata, symbols, child))
+    True
 
     >>> verifyClass(IQuery, Query)
     True
-	>>> verifyObject(IQuery, Query(metadata, symbols, set, [child], child))
-	True
+    >>> verifyObject(IQuery, Query(metadata, symbols, set, [child], child))
+    True
 
     >>> verifyClass(IIn, In)
     True
-	>>> verifyObject(IIn, In(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IIn, In(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IAlias, Alias)
     True
-	>>> verifyObject(IAlias, Alias(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IAlias, Alias(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IBinary, Binary)
     True
-	>>> verifyObject(IBinary, Binary(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IBinary, Binary(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IUnion, Union)
     True
-	>>> verifyObject(IUnion, Union(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IUnion, Union(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IDiffer, Differ)
     True
-	>>> verifyObject(IDiffer, Differ(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IDiffer, Differ(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IAnd, And)
     True
-	>>> verifyObject(IAnd, And(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IAnd, And(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IOr, Or)
     True
-	>>> verifyObject(IOr, Or(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IOr, Or(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IProperty, Property)
     True
-	>>> verifyObject(IProperty, Property(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IProperty, Property(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IIndex, Index)
     True
-	>>> verifyObject(IIndex, Index(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IIndex, Index(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IArithmetic, Arithmetic)
     True
-	>>> verifyObject(IArithmetic, Arithmetic(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IArithmetic, Arithmetic(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IAdd, Add)
     True
-	>>> verifyObject(IAdd, Add(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IAdd, Add(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IMul, Mul)
     True
-	>>> verifyObject(IMul, Mul(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IMul, Mul(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(ISub, Sub)
     True
-	>>> verifyObject(ISub, Sub(metadata, symbols, child, child))
-	True
+    >>> verifyObject(ISub, Sub(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IDiv, Div)
     True
-	>>> verifyObject(IDiv, Div(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IDiv, Div(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IUnary, Unary)
     True
-	>>> verifyObject(IUnary, Unary(metadata, symbols, child))
-	True
+    >>> verifyObject(IUnary, Unary(metadata, symbols, child))
+    True
 
     >>> verifyClass(INot, Not)
     True
-	>>> verifyObject(INot , Not(metadata, symbols, child))
-	True
+    >>> verifyObject(INot , Not(metadata, symbols, child))
+    True
 
     >>> verifyClass(IAggregate, Aggregate)
     True
-	>>> verifyObject(IAggregate, Aggregate(metadata, symbols, child))
-	True
+    >>> verifyObject(IAggregate, Aggregate(metadata, symbols, child))
+    True
 
     >>> verifyClass(ICount, Count)
     True
-	>>> verifyObject(ICount, Count(metadata, symbols, child))
-	True
+    >>> verifyObject(ICount, Count(metadata, symbols, child))
+    True
 
     >>> verifyClass(ISum, Sum)
     True
-	>>> verifyObject(ISum, Sum(metadata, symbols, child))
-	True
+    >>> verifyObject(ISum, Sum(metadata, symbols, child))
+    True
 
     >>> verifyClass(IQuantor, Quantor)
     True
-	>>> verifyObject(IQuantor, Quantor(metadata, symbols, child))
-	True
+    >>> verifyObject(IQuantor, Quantor(metadata, symbols, child))
+    True
 
     >>> verifyClass(IQuanted, Quanted)
     True
-	>>> verifyObject(IQuanted, Quanted(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IQuanted, Quanted(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IEvery, Every)
     True
-	>>> verifyObject(IEvery, Every(metadata, symbols, child))
-	True
+    >>> verifyObject(IEvery, Every(metadata, symbols, child))
+    True
 
     >>> verifyClass(ISome, Some)
     True
-	>>> verifyObject(ISome, Some(metadata, symbols, child))
-	True
+    >>> verifyObject(ISome, Some(metadata, symbols, child))
+    True
 
     >>> verifyClass(IAtmost, Atmost)
     True
-	>>> verifyObject(IAtmost, Atmost(metadata, symbols, child))
-	True
+    >>> verifyObject(IAtmost, Atmost(metadata, symbols, child))
+    True
 
     >>> verifyClass(IAtleast, Atleast)
     True
-	>>> verifyObject(IAtleast, Atleast(metadata, symbols, child))
-	True
+    >>> verifyObject(IAtleast, Atleast(metadata, symbols, child))
+    True
 
     >>> verifyClass(IJust, Just)
     True
-	>>> verifyObject(IJust, Just(metadata, symbols, child))
-	True
+    >>> verifyObject(IJust, Just(metadata, symbols, child))
+    True
 
     >>> verifyClass(ICondition, Condition)
     True
-	>>> verifyObject(ICondition, Condition(metadata, symbols, child, child))
-	True
+    >>> verifyObject(ICondition, Condition(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IEq, Eq)
     True
-	>>> verifyObject(IEq, Eq(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IEq, Eq(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(INe, Ne)
     True
-	>>> verifyObject(INe, Ne(metadata, symbols, child, child))
-	True
+    >>> verifyObject(INe, Ne(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(ILt, Lt)
     True
-	>>> verifyObject(ILt, Lt(metadata, symbols, child, child))
-	True
+    >>> verifyObject(ILt, Lt(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IGt, Gt)
     True
-	>>> verifyObject(IGt, Gt(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IGt, Gt(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(ILe, Le)
     True
-	>>> verifyObject(ILe, Le(metadata, symbols, child, child))
-	True
+    >>> verifyObject(ILe, Le(metadata, symbols, child, child))
+    True
 
     >>> verifyClass(IGe, Ge)
     True
-	>>> verifyObject(IGe, Ge(metadata, symbols, child, child))
-	True
+    >>> verifyObject(IGe, Ge(metadata, symbols, child, child))
+    True

Modified: Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/algebra.txt
===================================================================
--- Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/algebra.txt	2008-08-06 10:59:25 UTC (rev 89433)
+++ Sandbox/adamg/ocql/branches/qo-compiler/src/ocql/rewriter/algebra.txt	2008-08-06 10:59:52 UTC (rev 89434)
@@ -14,91 +14,91 @@
     >>> verifyClass(IAlgebraObjectHead, Head)
     True
     >>> baseAlgebra = BaseAlgebra()
-	>>> verifyObject(IAlgebraObjectHead, Head(baseAlgebra))
-	True
+    >>> verifyObject(IAlgebraObjectHead, Head(baseAlgebra))
+    True
 
     >>> verifyClass(IAlgebraObject, BaseAlgebra)
     True
-	>>> verifyObject(IAlgebraObject, baseAlgebra)
-	True
+    >>> verifyObject(IAlgebraObject, baseAlgebra)
+    True
 
     >>> verifyClass(IEmpty, Empty)
     True
-	>>> verifyObject(IEmpty, Empty(set))
-	True
+    >>> verifyObject(IEmpty, Empty(set))
+    True
 
     >>> verifyClass(ISingle, Single)
     True
-	>>> verifyObject(ISingle, Single(set, baseAlgebra))
-	True
+    >>> verifyObject(ISingle, Single(set, baseAlgebra))
+    True
 
     >>> verifyClass(IUnion, Union)
     True
-	>>> verifyObject(IUnion, Union(set, baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(IUnion, Union(set, baseAlgebra, baseAlgebra))
+    True
 
     >>> verifyClass(IDiffer, Differ)
     True
-	>>> verifyObject(IDiffer, Differ(set, baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(IDiffer, Differ(set, baseAlgebra, baseAlgebra))
+    True
 
     >>> verifyClass(IIter, Iter)
     True
-	>>> verifyObject(IIter, Iter(set, baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(IIter, Iter(set, baseAlgebra, baseAlgebra))
+    True
 
     >>> verifyClass(ISelect, Select)
     True
-	>>> verifyObject(ISelect, Select(set, baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(ISelect, Select(set, baseAlgebra, baseAlgebra))
+    True
 
     >>> verifyClass(IReduce, Reduce)
     True
-	>>> verifyObject(IReduce, Reduce(set, baseAlgebra, baseAlgebra, baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(IReduce, Reduce(set, baseAlgebra, baseAlgebra, baseAlgebra, baseAlgebra))
+    True
 
     >>> verifyClass(IRange, Range)
     True
-	>>> verifyObject(IRange, Range(set, baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(IRange, Range(set, baseAlgebra, baseAlgebra))
+    True
 
     >>> verifyClass(IMake, Make)
     True
-	>>> verifyObject(IMake, Make(baseAlgebra, baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(IMake, Make(baseAlgebra, baseAlgebra, baseAlgebra))
+    True
 
-	#Uncomment this after merge other branch modifications
+    #Uncomment this after merge other branch modifications
     #>>> verifyClass(IMakeFromIndex, MakeFromIndex)
     #True
-	#>>> verifyObject(IMakeFromIndex, MakeFromIndex(baseAlgebra, baseAlgebra, baseAlgebra, baseAlgebra))
-	#True
+    #>>> verifyObject(IMakeFromIndex, MakeFromIndex(baseAlgebra, baseAlgebra, baseAlgebra, baseAlgebra))
+    #True
 
     >>> verifyClass(IIf, If)
     True
-	>>> verifyObject(IIf, If(baseAlgebra, baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(IIf, If(baseAlgebra, baseAlgebra, baseAlgebra))
+    True
 
     >>> verifyClass(ILambda, Lambda)
     True
-	>>> verifyObject(ILambda, Lambda(baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(ILambda, Lambda(baseAlgebra, baseAlgebra))
+    True
 
     >>> verifyClass(IConstant, Constant)
     True
-	>>> verifyObject(IConstant, Constant(baseAlgebra))
-	True
+    >>> verifyObject(IConstant, Constant(baseAlgebra))
+    True
 
     >>> verifyClass(IIdentifier, Identifier)
     True
-	>>> verifyObject(IIdentifier, Identifier(baseAlgebra))
-	True
+    >>> verifyObject(IIdentifier, Identifier(baseAlgebra))
+    True
 
     >>> verifyClass(IBinary, Binary)
     True
-	>>> verifyObject(IBinary, Binary(baseAlgebra, baseAlgebra, baseAlgebra))
-	True
+    >>> verifyObject(IBinary, Binary(baseAlgebra, baseAlgebra, baseAlgebra))
+    True
 
     >>> verifyClass(IOperator, Operator)
     True
-	>>> verifyObject(IOperator, Operator(baseAlgebra))
-	True
+    >>> verifyObject(IOperator, Operator(baseAlgebra))
+    True