def setUp(self): self.parser = "unused" ################################# # Pathological case - Do not test #self.token_null = template.Token(template.TOKEN_BLOCK, "") ################################# self.token_noarg = template.Token(template.TOKEN_BLOCK, "test") self.token_onearg = template.Token(template.TOKEN_BLOCK, "test '%s'" % code9) self.token_twoarg = template.Token(template.TOKEN_BLOCK, "test '%s' '%s'" % (code9, code7)) self.site = Site.objects.get_current()
def test_node_can_have_no_args_with_default_value(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name "a"') node = MyEasyNodeWithoutDefaults.parse(parser, token) self.assertEquals(u'a', node.args[0].var)
def compile(self, tagfunc, token_contents): """ Mock out a call to a template compliation function. Assumes the tag doesn't use the parser, so this won't work for block tags. """ t = template.Token(template.TOKEN_BLOCK, token_contents) return tagfunc(None, t)
def test_node_parse_returns_node_instance(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name arg1 kwarg1="a=1"') node = MyEasyNode.parse(parser, token) self.assertTrue(isinstance(node, MyEasyNode)) self.assertEquals(u'arg1', node.args[0].token) self.assertEquals(u'"a=1"', node.kwargs['kwarg1'].token)
def contextblock(parser, token): """ A special :tag:`block` tag which does not render anything but can be used to modify a template context. The tag is rendered first thus modifying context before other blocks are rendered. A tag in an extending template is rendered after parent tags, allowing you to override template context in child templates. The tag has to be the first tag, immediately after the :tag:`extends` tag. You have to define a empty context block tag at the very start of your base template. Example usage, in your base template:: {% contextblock %}{% endcontextblock %}<html> <body> <head> <title>{{ title }}</title> </head> <body> <h1>{{ title }}</h1> <p><a href="{{ homepage }}">{{ title }}</a></p> </body> </body> </html> In your extending template:: {% extends "base.html" %} {% contextblock %} {% load future i18n %} {% setcontext as title %}{% blocktrans %}{{ username }}'s blog{% endblocktrans %}{% endsetcontext %} {% url "homepage" as homepage %} {% endcontextblock %} """ nodelist = parser.parse(('endcontextblock',)) # Make sure we call block.super at least once # (and in ContextBlockNode.super we make sure it is called only once) block_super_token = template.Token(template.TOKEN_VAR, 'block.super') if hasattr(token, 'source'): block_super_token.source = token.source filter_expression = parser.compile_filter(block_super_token.contents) var_node = parser.create_variable_node(filter_expression) # To push it through the normal logic first parser.extend_nodelist(nodelist, var_node, block_super_token) # But we want it at the very beginning var_node = nodelist.pop() nodelist.insert(0, var_node) parser.delete_first_token() return ContextBlockNode(None, nodelist)
def test_node_verifies_if_required_kwarg_is_specified_when_code_can_receive_kwargs( self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name arg2="2"') MyEasyNode = type( 'MyEasyNode', (EasyNode, ), { 'render_context': lambda self, context, arg1, **kwargs: True }) self.assertRaises(TemplateSyntaxError, MyEasyNode.parse, parser, token)
def test_node_verifies_if_required_arg_is_specified_two_times(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name "required" arg1="3"') MyEasyNode = type('MyEasyNode', (EasyNode, ), { 'render_context': lambda self, context, arg1, *args, **kwargs: True }) self.assertRaises(TemplateSyntaxError, MyEasyNode.parse, parser, token)
def test_parse_tag_with_equals_in_arg_value(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name "a=1"') args_kwargs = EasyNode.parse_to_args_kwargs(parser, token) args_kwargs_str = { 'args': tuple([x.token for x in args_kwargs['args']]), 'kwargs': dict((key, value.token) for key, value in args_kwargs['kwargs'].iteritems()) } self.assertEquals({'args': ('"a=1"', ), 'kwargs': {}}, args_kwargs_str)
def _build_choices(self): """Build choices list runtime using 'sitetree_tree' tag""" tree_token = u'sitetree_tree from "%s" template "%s"' % (self.tree, self.template) choices_str = sitetree_tree(template.Parser(None), template.Token(token_type=template.TOKEN_BLOCK, contents=tree_token)).render(template.Context(current_app='admin')) tree_choices = [('', self.root_title)] for line in choices_str.splitlines(): if line.strip(): splitted = line.split(':::') tree_choices.append((splitted[0], mark_safe(splitted[1]))) return tree_choices
def test_easy_library_register_easy_node_with_parameters(self): def test_tag(context, arg1): return arg1 register = EasyLibrary() register.easytag(test_tag) parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'test_tag "my arg"') test_node = register.tags['test_tag'](parser, token) context = template.Context({}) self.assertEquals(u'my arg', test_node.render(context))
def test_node_applies_filters_to_variable_in_kwargs(self): parser = template.Parser([]) context = Context({'variable': "string1 string2"}) token = template.Token(template.TOKEN_BLOCK, 'tag_name arg1=variable|slugify|upper') args_kwargs = EasyNode.parse_to_args_kwargs(parser, token) node = MyEasyNode(args_kwargs) self.assertEquals( u'STRING1-STRING2', node.render(context), )
def test_as_node_can_be_used_without_as_parameter(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, u'tag_name "value"') MyEasyAsNode = type( 'MyEasyAsNode', (EasyAsNode, ), { 'render_context': lambda self, context, arg1, **kwargs: arg1 }) node = MyEasyAsNode.parse(parser, token) context = Context() self.assertEqual('value', node.render(context))
def test_as_node_receives_as_parameter(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, u'tag_name as varname') MyEasyAsNode = type( 'MyEasyAsNode', (EasyAsNode, ), { 'render_context': lambda self, context, **kwargs: 'value' }) node = MyEasyAsNode.parse(parser, token) context = Context() self.assertEqual('', node.render(context)) self.assertEqual('value', context['varname'])
def test_if_node_can_receive_args_and_kwargs(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name "1" arg2="2"') MyEasyNode = type( 'MyEasyNode', (EasyNode, ), { 'render_context': lambda self, context, *args, **kwargs: args[0] + kwargs.items( )[0][0] + u'=' + kwargs.items()[0][1] }) node = MyEasyNode.parse(parser, token) self.assertEquals(u'1arg2=2', node.render(Context({})))
def test_node_can_receive_infinite_args(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name "a" "b" "c" "d"') MyEasyNode = type( 'MyEasyNodeWithArgs', (EasyNode, ), { 'render_context': lambda self, context, *args: reduce(lambda x, y: x + y, args) }) node = MyEasyNode.parse(parser, token) self.assertEquals(u'abcd', node.render(Context({})))
def test_node_can_receive_kwargs(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name arg1="bla" arg2="ble"') MyEasyNode = type('MyEasyNode', (EasyNode,), { 'render_context': lambda self, context, **kwargs:\ reduce(lambda x,y: u'%s%s' % (x, y), ['%s=%s' % (key, value) for key, value in kwargs.items()]) }) node = MyEasyNode.parse(parser, token) self.assertEquals(u'arg1=blaarg2=ble', node.render(Context({})))
def do_repo_url(parser, token): func_name, view_name, token_parts = token.contents.split(' ', 2) token_parts = token_parts.split(' ', 1) if len(token_parts) > 1: repo_obj_name = token_parts[0] new_token = token_parts[1] else: repo_obj_name = token_parts[0] new_token = '' return url( parser, template.Token( token.token_type, '%s %s %s.user.username %s.slug %s' % (func_name, view_name, repo_obj_name, repo_obj_name, new_token)))
def test_parse_tag_with_args(self): """ Tests if the parser recognizes one tag and parses its args """ parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name "arg1" "arg2"') args_kwargs = EasyNode.parse_to_args_kwargs(parser, token) args_kwargs_str = { 'args': tuple([x.token for x in args_kwargs['args']]), 'kwargs': dict((key, value.token) for key, value in args_kwargs['kwargs'].iteritems()) } self.assertEquals({ 'args': ('"arg1"', '"arg2"'), 'kwargs': {} }, args_kwargs_str)
def test_parse_tag_special_symbol_in_kwarg_value(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, u'tag_name kwarg1="será?"') args_kwargs = EasyNode.parse_to_args_kwargs(parser, token) args_kwargs_str = { 'args': tuple([x.token for x in args_kwargs['args']]), 'kwargs': dict((key, value.token) for key, value in args_kwargs['kwargs'].iteritems()) } self.assertEquals({ 'args': (), 'kwargs': { 'kwarg1': u'"será?"' } }, args_kwargs_str)
def test_easy_library_register_easy_node(self): def test_tag(context): return u'my return' register = EasyLibrary() register.easytag(test_tag) parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'test_tag') self.assertTrue('test_tag' in register.tags) test_node = register.tags['test_tag'](parser, token) self.assertTrue(isinstance(test_node, EasyNode)) context = template.Context({}) self.assertEquals(u'my return', test_node.render(context))
def get_form(self, request, obj=None, **kwargs): """Returns modified form for TreeItem model. 'Parent' field choices are built by sitetree itself. """ class TreeItemChoiceField(ChoiceField): """We use custom ChoiceField as to have a chance to resolve TreeItem by ID from dropdown. """ def clean(self, value): if value == '': return None return TreeItem.objects.get(pk=value) # We build choices dropdown using 'sitetree_tree' tag tree_token = u'sitetree_tree from "%s" template "admin/sitetree/tree/tree_combo.html"' % self.tree.alias my_context = template.RequestContext(request, current_app='admin') choices_str = sitetree_tree(template.Parser(None), template.Token(token_type=template.TOKEN_BLOCK, contents=tree_token)).render(my_context) tree_choices = [('', '---------')] for line in choices_str.splitlines(): if line.strip() != '': splitted = line.split(':::') tree_choices.append((splitted[0], mark_safe(splitted[1]))) if obj is not None and obj.parent is not None: self.previous_parent = obj.parent previous_parent_id = self.previous_parent.id else: previous_parent_id = None my_choice_field = TreeItemChoiceField(choices=tree_choices, initial=previous_parent_id) form = super(TreeItemAdmin, self).get_form(request, obj, **kwargs) my_choice_field.label = form.base_fields['parent'].label my_choice_field.help_text = form.base_fields['parent'].help_text # Replace 'parent' TreeItem field with new appropriate one form.base_fields['parent'] = my_choice_field return form
def testSyntax(self): tpl = template.Template( '{% load flatblock_tags %}{% flatblock "block" %}') tpl.render(template.Context({})) node = do_get_flatblock(None, template.Token('TOKEN_TEXT', 'flatblock "block"')) self.assertEqual('block', node.slug) self.assertEqual(False, node.evaluated) tpl = template.Template( '{% load flatblock_tags %}{% flatblock "block" 123 %}') tpl.render(template.Context({})) node = do_get_flatblock(None, template.Token('TOKEN_TEXT', 'flatblock "block" 123')) self.assertEqual('block', node.slug) self.assertEqual(False, node.evaluated) self.assertEqual(123, node.cache_time) tpl = template.Template( '{% load flatblock_tags %}' '{% flatblock "block" using "flatblocks/flatblock.html" %}') tpl.render(template.Context({})) node = do_get_flatblock(None, template.Token('TOKEN_TEXT', 'flatblock "block" using ' '"flatblocks/flatblock.html"')) self.assertEqual('block', node.slug) self.assertEqual(False, node.evaluated) self.assertEqual(0, node.cache_time) self.assertEqual("flatblocks/flatblock.html", node.template_name) tpl = template.Template( '{% load flatblock_tags %}' '{% flatblock "block" 123 using "flatblocks/flatblock.html" %}') tpl.render(template.Context({})) node = do_get_flatblock(None, template.Token('TOKEN_TEXT', 'flatblock "block" 123 using ' '"flatblocks/flatblock.html"')) self.assertEqual('block', node.slug) self.assertEqual(False, node.evaluated) self.assertEqual(123, node.cache_time) self.assertEqual("flatblocks/flatblock.html", node.template_name) tpl = template.Template( '{% load flatblock_tags %}{% flatblock "block" evaluated %}') tpl.render(template.Context({})) node = do_get_flatblock(None, template.Token('TOKEN_TEXT', 'flatblock "block" evaluated')) self.assertEqual('block', node.slug) self.assertEqual(True, node.evaluated) self.assertEqual(0, node.cache_time) tpl = template.Template( '{% load flatblock_tags %}' '{% flatblock "block" evaluated using ' '"flatblocks/flatblock.html" %}') tpl.render(template.Context({})) node = do_get_flatblock(None, template.Token('TOKEN_TEXT', 'flatblock "block" evaluated ' 'using ' '"flatblocks/flatblock.html"')) self.assertEqual('block', node.slug) self.assertEqual(True, node.evaluated) self.assertEqual(0, node.cache_time) self.assertEqual("flatblocks/flatblock.html", node.template_name) tpl = template.Template( '{% load flatblock_tags %}{% flatblock "block" 123 evaluated %}') tpl.render(template.Context({})) node = do_get_flatblock(None, template.Token('TOKEN_TEXT', 'flatblock "block" 123 ' 'evaluated')) self.assertEqual(123, node.cache_time) self.assertEqual(True, node.evaluated) tpl = template.Template( '{% load flatblock_tags %}{% flatblock "block" 123 evaluated ' 'using "flatblocks/flatblock.html" %}') tpl.render(template.Context({})) node = do_get_flatblock(None, template.Token('TOKEN_TEXT', 'flatblock "block" 123 ' 'evaluated using ' '"flatblocks/flatblock.html"')) self.assertEqual('block', node.slug) self.assertEqual(True, node.evaluated) self.assertEqual(123, node.cache_time) self.assertEqual("flatblocks/flatblock.html", node.template_name)
def url(self, sitetree_item, tag_arguments=[], context=None): """Resolves item's URL. 'sitetree_item' points to TreeItem object, 'url' property of which is processed as URL pattern or simple URL. 'tag_arguments' is a list of additional arguments passed to 'sitetree_url' in template. """ if context is None: context = self.global_context if not isinstance(sitetree_item, TreeItem): sitetree_item = self.resolve_var(sitetree_item, context) # Resolve only if item's URL is marked as pattern. if sitetree_item.urlaspattern: resolved_var = self.resolve_var(sitetree_item.url, context) if isinstance(resolved_var, list): raise SiteTreeError( 'Named URL for "%s" sitetree item clashes with template variable name. Please change either name.' % sitetree_item.title) view_path = resolved_var.split(' ') # We should try to resolve URL parameters from site tree item. view_arguments = [] for view_argument in view_path[1:]: resolved = self.resolve_var(view_argument) # In case of non-ascii data we leave variable unresolved. if isinstance(resolved, unicode): if resolved.encode('ascii', 'ignore').decode('ascii') != resolved: resolved = view_argument view_arguments.append(resolved) # URL parameters from site tree item should be concatenated with # those from template. arguments_couled = tag_arguments + view_arguments view_arguments = [] for argument in arguments_couled: argument = str(argument) # To be able to process slug-like strings (strings with "-"'s and "_"'s) # we enclose those in double quotes. if '-' in argument or '_': argument = '"%s"' % argument view_arguments.append(argument) view_arguments = ' '.join(view_arguments).strip() view_path = view_path[0] url_pattern = u'%s %s' % (view_path, view_arguments) else: url_pattern = u'%s' % sitetree_item.url url_pattern = url_pattern.strip() # Create 'cache_urls' for this tree. tree_alias = sitetree_item.tree.alias entry_from_cache = self.get_cache_entry('urls', tree_alias) if not entry_from_cache: entry_from_cache = {} self.set_cache_entry('urls', tree_alias, {}) if url_pattern in entry_from_cache: resolved_url = entry_from_cache[url_pattern][0] else: if sitetree_item.urlaspattern: # Form token to pass to Django 'url' tag. url_token = u'url %s as item.url_resolved' % url_pattern url_tag( template.Parser(None), template.Token(token_type=template.TOKEN_BLOCK, contents=url_token)).render(context) # We make an anchor link from an unresolved URL as a reminder. if context['item.url_resolved'] == '': resolved_url = u'#unresolved' else: resolved_url = context['item.url_resolved'] else: resolved_url = url_pattern self.update_cache_entry_value( 'urls', tree_alias, {url_pattern: (resolved_url, sitetree_item)}) return resolved_url
def test_token_smart_split(self): # Regression test for #7027 token = template.Token(template.TOKEN_BLOCK, 'sometag _("Page not found") value|yesno:_("yes,no")') split = token.split_contents() self.assertEqual(split, ["sometag", '_("Page not found")', 'value|yesno:_("yes,no")'])
def url(self, sitetree_item, context=None): """Resolves item's URL. 'sitetree_item' points to TreeItem object, 'url' property of which is processed as URL pattern or simple URL. """ if context is None: context = self._global_context if not isinstance(sitetree_item, MODEL_TREE_ITEM_CLASS): sitetree_item = self.resolve_var(sitetree_item, context) # Resolve only if item's URL is marked as pattern. if sitetree_item.urlaspattern: url = sitetree_item.url view_path = url all_arguments = [] if ' ' in url: view_path = url.split(' ') # We should try to resolve URL parameters from site tree item. for view_argument in view_path[1:]: resolved = self.resolve_var(view_argument) # In case of non-ascii data we leave variable unresolved. if isinstance(resolved, six.text_type): if resolved.encode('ascii', 'ignore').decode('ascii') != resolved: resolved = view_argument # URL parameters from site tree item should be concatenated with those from template. all_arguments.append('"%s"' % str(resolved)) # We enclose arg in double quotes as already resolved. view_path = view_path[0].strip('"\' ') if VERSION >= (1, 5, 0): # "new-style" url tag - consider sitetree named urls literals. view_path = "'%s'" % view_path url_pattern = u'%s %s' % (view_path, ' '.join(all_arguments)) else: url_pattern = str(sitetree_item.url) tree_alias = sitetree_item.tree.alias entry_from_cache = self.get_cache_entry('urls', tree_alias) if not entry_from_cache: # Create 'cache_urls' for this tree. entry_from_cache = {} self.set_cache_entry('urls', tree_alias, {}) if url_pattern in entry_from_cache: resolved_url = entry_from_cache[url_pattern][0] else: if sitetree_item.urlaspattern: # Form token to pass to Django 'url' tag. url_token = u'url %s as item.url_resolved' % url_pattern url_tag(template.Parser(None), template.Token(token_type=template.TOKEN_BLOCK, contents=url_token)).render(context) # We make an anchor link from an unresolved URL as a reminder. if not context['item.url_resolved']: resolved_url = UNRESOLVED_ITEM_MARKER else: resolved_url = context['item.url_resolved'] else: resolved_url = url_pattern self.update_cache_entry_value('urls', tree_alias, {url_pattern: (resolved_url, sitetree_item)}) return resolved_url
def getNode(self, strng): from geotagging.templatetags.geotagging_tags import get_objects_nearby return get_objects_nearby(None, template.Token(template.TOKEN_BLOCK, strng))
def url(self, sitetree_item, tag_arguments=None, context=None): """Resolves item's URL. 'sitetree_item' points to TreeItem object, 'url' property of which is processed as URL pattern or simple URL. 'tag_arguments' is a list of additional arguments passed to 'sitetree_url' in template. """ if tag_arguments is None: tag_arguments = [] else: # TODO Remove tag_arguments in 1.0. warnings.warn( 'Use of sitetree_url tag additional arguments is deprecated. Feature support will be completely removed in 1.0.', DeprecationWarning) if context is None: context = self._global_context if not isinstance(sitetree_item, TreeItem): sitetree_item = self.resolve_var(sitetree_item, context) # Resolve only if item's URL is marked as pattern. if sitetree_item.urlaspattern: resolved_var = self.resolve_var(sitetree_item.url, context) # Check whether a template variable is used instead of a URL pattern. if resolved_var != sitetree_item.url: if not isinstance( resolved_var, six.string_types ): # Variable contains what we're not expecting, revert to original URL. resolved_var = sitetree_item.url # TODO Remove template var resolution in 1.0. warnings.warn( 'Use of a template variable in URL field is deprecated. Feature support will be completely removed in 1.0.', DeprecationWarning) view_path = resolved_var all_arguments = copy(tag_arguments) if ' ' in resolved_var: view_path = resolved_var.split(' ') # We should try to resolve URL parameters from site tree item. for view_argument in view_path[1:]: resolved = self.resolve_var(view_argument) # In case of non-ascii data we leave variable unresolved. if isinstance(resolved, six.text_type): if resolved.encode( 'ascii', 'ignore').decode('ascii') != resolved: resolved = view_argument # URL parameters from site tree item should be concatenated with those from template. all_arguments.append( '"%s"' % str(resolved) ) # We enclose arg in double quotes as already resolved. view_path = view_path[0].strip('"\' ') if DJANGO_VERSION_INT >= 150: # "new-style" url tag - consider sitetree named urls literals. view_path = "'%s'" % view_path url_pattern = u'%s %s' % (view_path, ' '.join(all_arguments)) else: url_pattern = str(sitetree_item.url) tree_alias = sitetree_item.tree.alias entry_from_cache = self.get_cache_entry('urls', tree_alias) if not entry_from_cache: # Create 'cache_urls' for this tree. entry_from_cache = {} self.set_cache_entry('urls', tree_alias, {}) if url_pattern in entry_from_cache: resolved_url = entry_from_cache[url_pattern][0] else: if sitetree_item.urlaspattern: # Form token to pass to Django 'url' tag. url_token = u'url %s as item.url_resolved' % url_pattern url_tag( template.Parser(None), template.Token(token_type=template.TOKEN_BLOCK, contents=url_token)).render(context) # We make an anchor link from an unresolved URL as a reminder. if not context['item.url_resolved']: resolved_url = u'#unresolved' else: resolved_url = context['item.url_resolved'] else: resolved_url = url_pattern self.update_cache_entry_value( 'urls', tree_alias, {url_pattern: (resolved_url, sitetree_item)}) return resolved_url
def test_node_parse_verifies_if_there_are_less_args_kwargs_then_method_requires( self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name') self.assertRaises(TemplateSyntaxError, MyEasyNode.parse, parser, token)
def test_node_parse_verifies_kwarg_already_satisfied_by_arg(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name arg1 arg1="a=1"') self.assertRaises(TemplateSyntaxError, MyEasyNode.parse, parser, token)
def test_node_parse_verifies_if_required_arg_is_specified(self): parser = template.Parser([]) token = template.Token(template.TOKEN_BLOCK, 'tag_name kwarg1="a"') self.assertRaises(TemplateSyntaxError, MyEasyNode.parse, parser, token)