Refactor Cheetah.Parser.ArgList

Added a test for ArgList as well; a large amount of code in
Cheetah.Parser could do well to be cleaned up, but perhaps another
day.

3 files changed, 72 insertions, 24 deletions

diff --git a/cheetah/Parser.py b/cheetah/Parser.py
index 3eccc50..904a0ca 100644
--- a/cheetah/Parser.py
+++ b/cheetah/Parser.py
@@ -314,36 +314,33 @@ class CheetahVariable:
         self.cacheToken = cacheToken
         self.rawSource = rawSource
         
-class Placeholder(CheetahVariable): pass
+class Placeholder(CheetahVariable):
+    pass
 
-class ArgList:
+class ArgList(object):
     """Used by _LowLevelParser.getArgList()"""
 
     def __init__(self):
-        self.argNames = []
-        self.defVals = []
-        self.i = 0
+        self.arguments = []
+        self.defaults = []
+        self.count = 0
 
-    def addArgName(self, name):
-        self.argNames.append( name )
-        self.defVals.append( None )
+    def add_argument(self, name):
+        self.arguments.append(name)
+        self.defaults.append(None)
 
     def next(self):
-        self.i += 1
+        self.count += 1
 
-    def addToDefVal(self, token):
-        i = self.i
-        if self.defVals[i] == None:
-            self.defVals[i] = ''
-        self.defVals[i] += token
+    def add_default(self, token):
+        count = self.count
+        if self.defaults[count] is None:
+            self.defaults[count] = ''
+        self.defaults[count] += token
     
     def merge(self):
-        defVals = self.defVals
-        for i in range(len(defVals)):
-            if type(defVals[i]) == StringType:
-                defVals[i] = defVals[i].strip()
-                
-        return map(None, [i.strip() for i in self.argNames], defVals)
+        defaults = (isinstance(d, basestring) and d.strip() or None for d in self.defaults)
+        return list(map(None, (a.strip() for a in self.arguments), defaults))
     
     def __str__(self):
         return str(self.merge())
@@ -1034,7 +1031,7 @@ class _LowLevelParser(SourceReader):
                 break            
             elif c in " \t\f\r\n":
                 if onDefVal:
-                    argList.addToDefVal(c)
+                    argList.add_default(c)
                 self.advance()
             elif c == '=':
                 onDefVal = True
@@ -1046,7 +1043,7 @@ class _LowLevelParser(SourceReader):
             elif self.startswith(self.cheetahVarStartToken) and not onDefVal:
                 self.advance(len(self.cheetahVarStartToken))
             elif self.matchIdentifier() and not onDefVal:
-                argList.addArgName( self.getIdentifier() )
+                argList.add_argument( self.getIdentifier() )
             elif onDefVal:
                 if self.matchCheetahVarInExpressionStartToken():
                     token = self.getCheetahVar()
@@ -1060,7 +1057,7 @@ class _LowLevelParser(SourceReader):
                         self.rev()
                         token = self.getExpression(enclosed=True)
                     token = self.transformToken(token, beforeTokenPos)
-                argList.addToDefVal(token)
+                argList.add_default(token)
             elif c == '*' and not onDefVal:
                 varName = self.getc()
                 if self.peek() == '*':
@@ -1068,7 +1065,7 @@ class _LowLevelParser(SourceReader):
                 if not self.matchIdentifier():
                     raise ParseError(self)
                 varName += self.getIdentifier()
-                argList.addArgName(varName)
+                argList.add_argument(varName)
             else:
                 raise ParseError(self)
 
diff --git a/cheetah/Tests/Parser.py b/cheetah/Tests/Parser.py
new file mode 100644
index 0000000..050b613
--- /dev/null
+++ b/cheetah/Tests/Parser.py
@@ -0,0 +1,49 @@
+#!/usr/bin/env python
+
+import unittest
+
+from Cheetah import Parser
+
+class ArgListTest(unittest.TestCase):
+    def setUp(self):
+        super(ArgListTest, self).setUp()
+        self.al = Parser.ArgList()
+
+    def test_merge1(self):
+        ''' 
+            Testing the ArgList case results from Template.Preprocessors.test_complexUsage 
+        '''
+        self.al.add_argument('arg')
+        expect = [('arg', None)]
+
+        self.assertEquals(expect, self.al.merge())
+
+    def test_merge2(self):
+        '''
+            Testing the ArgList case results from SyntaxAndOutput.BlockDirective.test4
+        '''
+        self.al.add_argument('a')
+        self.al.add_default('999')
+        self.al.next()
+        self.al.add_argument('b')
+        self.al.add_default('444')
+
+        expect = [(u'a', u'999'), (u'b', u'444')]
+
+        self.assertEquals(expect, self.al.merge())
+
+
+
+    def test_merge3(self):
+        '''
+            Testing the ArgList case results from SyntaxAndOutput.BlockDirective.test13
+        '''
+        self.al.add_argument('arg')
+        self.al.add_default("'This is my block'")
+        expect = [('arg', "'This is my block'")]
+
+        self.assertEquals(expect, self.al.merge())
+
+if __name__ == '__main__':
+    unittest.main()
+
diff --git a/cheetah/Tests/Test.py b/cheetah/Tests/Test.py
index 872de8e..056fdb5 100755
--- a/cheetah/Tests/Test.py
+++ b/cheetah/Tests/Test.py
@@ -19,6 +19,7 @@ import Misc
 import Filters
 import Template
 import Cheps
+import Parser
 import Regressions
 import Unicode
 import CheetahWrapper
@@ -34,6 +35,7 @@ suites = [
    unittest.findTestCases(Regressions),
    unittest.findTestCases(Unicode),
    unittest.findTestCases(Misc),
+   unittest.findTestCases(Parser),
 ]
 
 if not sys.platform.startswith('java'):