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)
