From 2eefc18de8369bae9f6b22c5726aa7f34b8af629 Mon Sep 17 00:00:00 2001
From: Jonas Obrist <jonas.obrist@divio.ch>
Date: Wed, 2 Mar 2011 14:39:52 +0100
Subject: [PATCH] Fixed issues with MultiKeywordArgument and KeywordArgument
 when required=False. Also fixed resolving issues with MultiKeywordArgument
 and KeywordArgument Thanks to Chris Glass for finding these issues

---
 classytags/arguments.py | 28 +++++++++++++------------
 classytags/tests.py     | 45 ++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 59 insertions(+), 14 deletions(-)

diff --git a/classytags/arguments.py b/classytags/arguments.py
index 8db2007..3b67221 100644
--- a/classytags/arguments.py
+++ b/classytags/arguments.py
@@ -57,19 +57,21 @@ def __init__(self, name, default=None, required=True, resolve=True,
         self.splitter = splitter
         
     def get_default(self):
-        return self.wrapper_class({
-            self.defaultkey: TemplateConstant(self.default)
-        })
+        if self.defaultkey:
+            return self.wrapper_class({
+                self.defaultkey: TemplateConstant(self.default)
+            })
+        else:
+            return self.wrapper_class({})
     
     def parse_token(self, parser, token):
         if self.splitter in token:
-            key, value = token.split(self.splitter, 1)
-            if self.resolve:
-                return key, parser.compile_filter(value)
-            else:
-                return key, TemplateConstant(value)
-        parsed = super(KeywordArgument, self).parse_token(parser, token)
-        return self.defaultkey, parsed
+            key, raw_value = token.split(self.splitter, 1)
+            value = super(KeywordArgument, self).parse_token(parser, raw_value)
+        else:
+            key = self.defaultkey
+            value = super(KeywordArgument, self).parse_token(parser, token)
+        return key, self.value_class(value)
         
     def parse(self, parser, token, tagname, kwargs):
         if self.name in kwargs: # pragma: no cover 
@@ -77,7 +79,7 @@ def parse(self, parser, token, tagname, kwargs):
         else:
             key, value = self.parse_token(parser, token)
             kwargs[self.name] = self.wrapper_class({
-                key: self.value_class(value)
+                key: value
             })
             return True
         
@@ -156,10 +158,10 @@ def parse(self, parser, token, tagname, kwargs):
         if self.name in kwargs:
             if self.max_values and len(kwargs[self.name]) == self.max_values:
                 return False
-            kwargs[self.name][key] = self.value_class(value)
+            kwargs[self.name][key] = value
         else:
             kwargs[self.name] = self.wrapper_class({
-                key: self.value_class(value)
+                key: value
             })
         return True
 
diff --git a/classytags/tests.py b/classytags/tests.py
index 6e49bcc..93302ed 100644
--- a/classytags/tests.py
+++ b/classytags/tests.py
@@ -779,4 +779,47 @@ def test_21_repr(self):
         class MyTag(core.Tag):
             name = 'mytag'
         tag = MyTag(dummy_parser, DummyTokens())
-        self.assertEqual('<Tag: mytag>', repr(tag))
\ No newline at end of file
+        self.assertEqual('<Tag: mytag>', repr(tag))
+        
+    def test_22_non_required_multikwarg(self):
+        options = core.Options(
+            arguments.MultiKeywordArgument('multi', required=False),
+        )
+        dummy_tokens = DummyTokens()
+        kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
+        self.assertTrue('multi' in kwargs)
+        self.assertEqual(kwargs['multi'], {})
+        
+    def test_23_resolve_kwarg(self):
+        class ResolveKwarg(core.Tag):
+            name = 'kwarg'
+            options = core.Options(
+                arguments.KeywordArgument('named'),
+            )
+            
+            def render_tag(self, context, named):
+                return '%s:%s' % (named.keys()[0], named.values()[0])
+        
+        class NoResolveKwarg(core.Tag):
+            name = 'kwarg'
+            options = core.Options(
+                arguments.KeywordArgument('named', resolve=False),
+            )
+            
+            def render_tag(self, context, named):
+                return '%s:%s' % (named.keys()[0], named.values()[0])
+        
+        resolve_templates = [
+            ("{% kwarg key=value %}", "key:test", {'value': 'test'}),
+        ]
+        
+        resolve_templates = [
+            ("{% kwarg key='value' %}", "key:value", {'value': 'test'}),
+        ]
+        
+        noresolve_templates = [
+            ("{% kwarg key=value %}", "key:value", {'value': 'test'}),
+        ]
+        
+        self._tag_tester(ResolveKwarg, resolve_templates)
+        self._tag_tester(NoResolveKwarg, noresolve_templates)
\ No newline at end of file