def test_post_order(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "bar")
l3 = pytree.Leaf(100, "fooey")
c1 = pytree.Node(1000, [l1, l2])
n1 = pytree.Node(1000, [c1, l3])
self.assertEqual(list(n1.post_order()), [l1, l2, c1, l3, n1])
def _InsertPseudoParentheses(node):
comment_node = None
if isinstance(node, pytree.Node):
if node.children[-1].type == token.COMMENT:
comment_node = node.children[-1].clone()
node.children[-1].remove()
first = _GetFirstLeafNode(node)
last = _GetLastLeafNode(node)
lparen = pytree.Leaf(token.LPAR,
u'(',
context=('', (first.get_lineno(), first.column - 1)))
rparen = pytree.Leaf(token.RPAR,
u')',
context=('', (last.get_lineno(),
last.column + len(last.value) + 1)))
lparen.is_pseudo = True
rparen.is_pseudo = True
if isinstance(node, pytree.Node):
node.insert_child(0, lparen)
node.append_child(rparen)
if comment_node:
node.append_child(comment_node)
else:
new_node = pytree.Node(syms.atom, [lparen, node.clone(), rparen])
node.replace(new_node)
def transform(self, node, results):
single = results.get("single")
if single:
# Make a fake listmaker
fake = pytree.Node(syms.listmaker, [single.clone()])
single.replace(fake)
items = fake
else:
items = results["items"]
# Build the contents of the literal
literal = [pytree.Leaf(token.LBRACE, u"{")]
literal.extend(n.clone() for n in items.children)
literal.append(pytree.Leaf(token.RBRACE, u"}"))
# Set the prefix of the right brace to that of the ')' or ']'
literal[-1].prefix = items.next_sibling.prefix
maker = pytree.Node(syms.dictsetmaker, literal)
maker.prefix = node.prefix
# If the original was a one tuple, we need to remove the extra comma.
if len(maker.children) == 4:
n = maker.children[2]
n.remove()
maker.children[-1].prefix = n.prefix
# Finally, replace the set call with our shiny new literal.
return maker
def test_wildcard(self):
# Build a tree for testing
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "bar")
l3 = pytree.Leaf(100, "foo")
n1 = pytree.Node(1000, [l1, l2])
n2 = pytree.Node(1000, [l3])
root = pytree.Node(1000, [n1, n2])
# Build a pattern
pl = pytree.LeafPattern(100, "foo", name="pl")
pn = pytree.NodePattern(1000, [pl], name="pn")
pw = pytree.WildcardPattern([[pn], [pl, pl]], name="pw")
r = {}
self.assertFalse(pw.match_seq([root], r))
self.assertEqual(r, {})
self.assertFalse(pw.match_seq([n1], r))
self.assertEqual(r, {})
self.assertTrue(pw.match_seq([n2], r))
# These are easier to debug
self.assertEqual(sorted(r.keys()), ["pl", "pn", "pw"])
self.assertEqual(r["pl"], l1)
self.assertEqual(r["pn"], n2)
self.assertEqual(r["pw"], [n2])
# But this is equivalent
self.assertEqual(r, {"pl": l1, "pn": n2, "pw": [n2]})
r = {}
self.assertTrue(pw.match_seq([l1, l3], r))
self.assertEqual(r, {"pl": l3, "pw": [l1, l3]})
self.assertIs(r["pl"], l3)
r = {}
def test_basic_patterns(self):
# Build a tree
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "bar")
l3 = pytree.Leaf(100, "foo")
n1 = pytree.Node(1000, [l1, l2])
n2 = pytree.Node(1000, [l3])
root = pytree.Node(1000, [n1, n2])
# Build a pattern matching a leaf
pl = pytree.LeafPattern(100, "foo", name="pl")
r = {}
self.assertFalse(pl.match(root, results=r))
self.assertEqual(r, {})
self.assertFalse(pl.match(n1, results=r))
self.assertEqual(r, {})
self.assertFalse(pl.match(n2, results=r))
self.assertEqual(r, {})
self.assertTrue(pl.match(l1, results=r))
self.assertEqual(r, {"pl": l1})
r = {}
self.assertFalse(pl.match(l2, results=r))
self.assertEqual(r, {})
# Build a pattern matching a node
pn = pytree.NodePattern(1000, [pl], name="pn")
self.assertFalse(pn.match(root, results=r))
self.assertEqual(r, {})
self.assertFalse(pn.match(n1, results=r))
self.assertEqual(r, {})
self.assertTrue(pn.match(n2, results=r))
self.assertEqual(r, {"pn": n2, "pl": l3})
r = {}
self.assertFalse(pn.match(l1, results=r))
self.assertEqual(r, {})
self.assertFalse(pn.match(l2, results=r))
self.assertEqual(r, {})
def test_changed(self):
l1 = pytree.Leaf(100, "f")
self.assertFalse(l1.was_changed)
l1.changed()
self.assertTrue(l1.was_changed)
l1 = pytree.Leaf(100, "f")
n1 = pytree.Node(1000, [l1])
self.assertFalse(n1.was_changed)
n1.changed()
self.assertTrue(n1.was_changed)
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "+")
l3 = pytree.Leaf(100, "bar")
n1 = pytree.Node(1000, [l1, l2, l3])
n2 = pytree.Node(1000, [n1])
self.assertFalse(l1.was_changed)
self.assertFalse(n1.was_changed)
self.assertFalse(n2.was_changed)
n1.changed()
self.assertTrue(n1.was_changed)
self.assertTrue(n2.was_changed)
self.assertFalse(l1.was_changed)
def _InsertPseudoParentheses(node):
"""Insert pseudo parentheses so that dicts can be formatted correctly."""
comment_node = None
if isinstance(node, pytree.Node):
if node.children[-1].type == grammar_token.COMMENT:
comment_node = node.children[-1].clone()
node.children[-1].remove()
first = pytree_utils.FirstLeafNode(node)
last = pytree_utils.LastLeafNode(node)
if first == last and first.type == grammar_token.COMMENT:
# A comment was inserted before the value, which is a pytree.Leaf.
# Encompass the dictionary's value into an ATOM node.
last = first.next_sibling
last_clone = last.clone()
new_node = pytree.Node(syms.atom, [first.clone(), last_clone])
for orig_leaf, clone_leaf in zip(last.leaves(), last_clone.leaves()):
pytree_utils.CopyYapfAnnotations(orig_leaf, clone_leaf)
if hasattr(orig_leaf, 'is_pseudo'):
clone_leaf.is_pseudo = orig_leaf.is_pseudo
node.replace(new_node)
node = new_node
last.remove()
first = pytree_utils.FirstLeafNode(node)
last = pytree_utils.LastLeafNode(node)
lparen = pytree.Leaf(grammar_token.LPAR,
u'(',
context=('', (first.get_lineno(), first.column - 1)))
last_lineno = last.get_lineno()
if last.type == grammar_token.STRING and '\n' in last.value:
last_lineno += last.value.count('\n')
if last.type == grammar_token.STRING and '\n' in last.value:
last_column = len(last.value.split('\n')[-1]) + 1
else:
last_column = last.column + len(last.value) + 1
rparen = pytree.Leaf(grammar_token.RPAR,
u')',
context=('', (last_lineno, last_column)))
lparen.is_pseudo = True
rparen.is_pseudo = True
if isinstance(node, pytree.Node):
node.insert_child(0, lparen)
node.append_child(rparen)
if comment_node:
node.append_child(comment_node)
_AppendFirstLeafTokenSubtype(node, subtypes.DICTIONARY_VALUE)
else:
clone = node.clone()
for orig_leaf, clone_leaf in zip(node.leaves(), clone.leaves()):
pytree_utils.CopyYapfAnnotations(orig_leaf, clone_leaf)
new_node = pytree.Node(syms.atom, [lparen, clone, rparen])
node.replace(new_node)
_AppendFirstLeafTokenSubtype(clone, subtypes.DICTIONARY_VALUE)
def testIsMultilineString(self):
tok = format_token.FormatToken(pytree.Leaf(token.STRING,
'"""hello"""'))
self.assertTrue(tok.is_multiline_string)
tok = format_token.FormatToken(
pytree.Leaf(token.STRING, 'r"""hello"""'))
self.assertTrue(tok.is_multiline_string)
def test_leaf_next_sibling(self):
l1 = pytree.Leaf(100, "a")
l2 = pytree.Leaf(100, "b")
p1 = pytree.Node(1000, [l1, l2])
self.assertTrue(l1.next_sibling is l2)
self.assertEqual(l2.next_sibling, None)
self.assertEqual(p1.next_sibling, None)
def test_leaf_prev_sibling(self):
l1 = pytree.Leaf(100, "a")
l2 = pytree.Leaf(100, "b")
p1 = pytree.Node(1000, [l1, l2])
self.assertIs(l2.prev_sibling, l1)
self.assertEqual(l1.prev_sibling, None)
self.assertEqual(p1.prev_sibling, None)
def test_leaf_equality(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "foo", context=(" ", (1, 0)))
self.assertEqual(l1, l2)
l3 = pytree.Leaf(101, "foo")
l4 = pytree.Leaf(100, "bar")
self.assertNotEqual(l1, l3)
self.assertNotEqual(l1, l4)
def test_replace_with_list(self):
l1 = pytree.Leaf(100, 'foo')
l2 = pytree.Leaf(100, '+')
l3 = pytree.Leaf(100, 'bar')
n1 = pytree.Node(1000, [l1, l2, l3])
l2.replace([pytree.Leaf(100, '*'), pytree.Leaf(100, '*')])
self.assertEqual(str(n1), 'foo**bar')
self.assertIsInstance(n1.children, list)
def test_leaves(self):
l1 = pytree.Leaf(100, 'foo')
l2 = pytree.Leaf(100, 'bar')
l3 = pytree.Leaf(100, 'fooey')
n2 = pytree.Node(1000, [l1, l2])
n3 = pytree.Node(1000, [l3])
n1 = pytree.Node(1000, [n2, n3])
self.assertEqual(list(n1.leaves()), [l1, l2, l3])
def test_leaf_equality(self):
l1 = pytree.Leaf(100, 'foo')
l2 = pytree.Leaf(100, 'foo', context=(' ', (1, 0)))
self.assertEqual(l1, l2)
l3 = pytree.Leaf(101, 'foo')
l4 = pytree.Leaf(100, 'bar')
self.assertNotEqual(l1, l3)
self.assertNotEqual(l1, l4)
def test_replace_with_list(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "+")
l3 = pytree.Leaf(100, "bar")
n1 = pytree.Node(1000, [l1, l2, l3])
l2.replace([pytree.Leaf(100, "*"), pytree.Leaf(100, "*")])
self.assertEqual(str(n1), "foo**bar")
self.assertIsInstance(n1.children, list)
def test_node_constructor_prefix(self):
for prefix in ("xyz_", ""):
l1 = pytree.Leaf(100, "self")
l2 = pytree.Leaf(100, "foo", prefix="_")
n1 = pytree.Node(1000, [l1, l2], prefix=prefix)
self.assertTrue(str(n1), prefix + "self_foo")
self.assertEqual(n1.prefix, prefix)
self.assertEqual(l1.prefix, prefix)
self.assertEqual(l2.prefix, "_")
def test_depth(self):
l1 = pytree.Leaf(100, 'foo')
l2 = pytree.Leaf(100, 'bar')
n2 = pytree.Node(1000, [l1, l2])
n3 = pytree.Node(1000, [])
n1 = pytree.Node(1000, [n2, n3])
self.assertEqual(l1.depth(), 2)
self.assertEqual(n3.depth(), 1)
self.assertEqual(n1.depth(), 0)
def test_node_constructor_prefix(self):
for prefix in ('xyz_', ''):
l1 = pytree.Leaf(100, 'self')
l2 = pytree.Leaf(100, 'foo', prefix='_')
n1 = pytree.Node(1000, [l1, l2], prefix=prefix)
self.assertTrue(str(n1), prefix + 'self_foo')
self.assertEqual(n1.prefix, prefix)
self.assertEqual(l1.prefix, prefix)
self.assertEqual(l2.prefix, '_')
def test_node_recursive_equality(self):
l1 = pytree.Leaf(100, 'foo')
l2 = pytree.Leaf(100, 'foo')
n1 = pytree.Node(1000, [l1])
n2 = pytree.Node(1000, [l2])
self.assertEqual(n1, n2)
l3 = pytree.Leaf(100, 'bar')
n3 = pytree.Node(1000, [l3])
self.assertNotEqual(n1, n3)
def testSimple(self):
tok = format_token.FormatToken(pytree.Leaf(token.STRING, "'hello world'"))
self.assertEqual("FormatToken(name=STRING, value='hello world', lineno=0)",
str(tok))
self.assertTrue(tok.is_string)
tok = format_token.FormatToken(pytree.Leaf(token.COMMENT, '# A comment'))
self.assertEqual('FormatToken(name=COMMENT, value=# A comment, lineno=0)',
str(tok))
self.assertTrue(tok.is_comment)
def transform(self, node, results):
if self.skip:
return
libmodernize.add_future(node, u'division')
if node.value == '/':
return pytree.Leaf(token.DOUBLESLASH, '//', prefix=node.prefix)
else:
return pytree.Leaf(token.DOUBLESLASHEQUAL,
'//=',
prefix=node.prefix)
def test_has_key_example(self):
pattern = pytree.NodePattern(
331, (pytree.LeafPattern(7), pytree.WildcardPattern(name='args'),
pytree.LeafPattern(8)))
l1 = pytree.Leaf(7, '(')
l2 = pytree.Leaf(3, 'x')
l3 = pytree.Leaf(8, ')')
node = pytree.Node(331, [l1, l2, l3])
r = {}
self.assertTrue(pattern.match(node, r))
self.assertEqual(r['args'], [l2])
def test_node_append_child(self):
n1 = pytree.Node(1000, [])
l1 = pytree.Leaf(100, 'foo')
n1.append_child(l1)
self.assertEqual(l1.parent, n1)
self.assertEqual(n1.children, [l1])
l2 = pytree.Leaf(100, 'bar')
n1.append_child(l2)
self.assertEqual(l2.parent, n1)
self.assertEqual(n1.children, [l1, l2])
self.assertRaises(Exception, n1.append_child, list)
def test_node_insert_child(self):
l1 = pytree.Leaf(100, 'foo')
n1 = pytree.Node(1000, [l1])
l2 = pytree.Leaf(100, 'bar')
n1.insert_child(0, l2)
self.assertEqual(l2.parent, n1)
self.assertEqual(n1.children, [l2, l1])
l3 = pytree.Leaf(100, 'abc')
n1.insert_child(2, l3)
self.assertEqual(n1.children, [l2, l1, l3])
self.assertRaises(Exception, n1.insert_child, 0, list)
def _insert_parens(self, node, first_idx, last_idx):
""" Insert parentheses around children range [first_idx, last_idx]
For example, this function will change `node` as follows:
# input subtree
#
if_stmt
"if"
and_test
...
":" prefix=""
suite prefix=""
...
# output subtree
#
if_stmt
"if"
atom
"("
and_test
...
")"
":" prefix=""
suite prefix=""
...
"""
assert isinstance(node, pytree.Node)
def get_column(node):
if isinstance(node, pytree.Leaf):
return node.column
return get_column(node.children[0])
first = node.children[first_idx]
last = node.children[last_idx]
lpar = pytree.Leaf(token.LPAR,
'(',
context=('', (first.get_lineno(),
get_column(first) - 1)))
rpar = pytree.Leaf(token.RPAR,
')',
context=('', (last.get_lineno(), get_column(last))))
new_node = pytree.Node(syms.atom, [lpar, rpar])
children = node.children[first_idx:last_idx + 1]
for child in children:
child.remove()
new_node.insert_child(1, child)
node.insert_child(first_idx, new_node)
def test_has_key_example(self):
pattern = pytree.NodePattern(
331, (pytree.LeafPattern(7), pytree.WildcardPattern(name="args"),
pytree.LeafPattern(8)))
l1 = pytree.Leaf(7, "(")
l2 = pytree.Leaf(3, "x")
l3 = pytree.Leaf(8, ")")
node = pytree.Node(331, [l1, l2, l3])
r = {}
self.assertTrue(pattern.match(node, r))
self.assertEqual(r["args"], [l2])
def test_get_suffix(self):
l1 = pytree.Leaf(100, 'foo', prefix='a')
l2 = pytree.Leaf(100, 'bar', prefix='b')
n1 = pytree.Node(1000, [l1, l2])
self.assertEqual(l1.get_suffix(), l2.prefix)
self.assertEqual(l2.get_suffix(), '')
self.assertEqual(n1.get_suffix(), '')
l3 = pytree.Leaf(100, 'bar', prefix='c')
n2 = pytree.Node(1000, [n1, l3])
self.assertEqual(n1.get_suffix(), l3.prefix)
self.assertEqual(l3.get_suffix(), '')
self.assertEqual(n2.get_suffix(), '')
def test_replace(self):
l1 = pytree.Leaf(100, 'foo')
l2 = pytree.Leaf(100, '+')
l3 = pytree.Leaf(100, 'bar')
n1 = pytree.Node(1000, [l1, l2, l3])
self.assertEqual(n1.children, [l1, l2, l3])
self.assertIsInstance(n1.children, list)
self.assertFalse(n1.was_changed)
l2new = pytree.Leaf(100, '-')
l2.replace(l2new)
self.assertEqual(n1.children, [l1, l2new, l3])
self.assertIsInstance(n1.children, list)
self.assertTrue(n1.was_changed)
def add_version(tree) -> pytree.Leaf:
"""Add a version node"""
setup_args = _searching.find_setup_args(tree)
version_node = pytree.Node(
python_symbols.argument,
[
pytree.Leaf(token.NAME, "version"),
pytree.Leaf(22, "="),
pytree.Leaf(token.STRING, '""'),
],
)
add_arg(setup_args, version_node)
return version_node.children[-1]
def test_replace(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "+")
l3 = pytree.Leaf(100, "bar")
n1 = pytree.Node(1000, [l1, l2, l3])
self.assertEqual(n1.children, [l1, l2, l3])
self.assertTrue(isinstance(n1.children, list))
self.assertFalse(n1.was_changed)
l2new = pytree.Leaf(100, "-")
l2.replace(l2new)
self.assertEqual(n1.children, [l1, l2new, l3])
self.assertTrue(isinstance(n1.children, list))
self.assertTrue(n1.was_changed)
