def mutate_node(i, context):
if not i:
return
context.stack.append(i)
try:
t = i['type']
if t == 'endl':
context.current_line += 1
assert t in mutations_by_type, (t, i.keys(), dumps(i))
m = mutations_by_type[t]
if 'replace_entire_node_with' in m:
if context.exclude_line():
return
if context.mutate_index in (ALL, context.index):
i.clear()
for k, v in m['replace_entire_node_with'].items():
i[k] = v
context.performed_mutations += 1
context.index += 1
return
for _, x in sorted(i.items()):
if x is None:
continue # pragma: no cover
if isinstance(x, list):
if x:
mutate_list_of_nodes(x, context=context)
elif isinstance(x, dict):
mutate_node(x, context=context)
else:
assert isinstance(x, text_types + (bool, ))
if context.performed_mutations and context.mutate_index != ALL:
return
for key, value in sorted(m.items()):
old = i[key]
if context.exclude_line():
continue
new = evaluate(value, context=context, node=i, **i)
assert not callable(new)
if new != old:
if context.mutate_index in (ALL, context.index):
context.performed_mutations += 1
i[key] = new
context.index += 1
if context.performed_mutations and context.mutate_index != ALL:
return
finally:
context.stack.pop()
def test_comment_before_while():
code = """
while cond:
pass
# comment
while cond:
pass
"""
assert dumps(parse(code)) == code
def test_comment_before_for():
code = """
for var in iter:
pass
# comment
for var in iter:
pass
"""
assert dumps(parse(code)) == code
def test_comment_before_if():
code = """
if cond:
pass
# comment
if cond:
pass
"""
assert dumps(parse(code)) == code
def test_comment_after_try_else():
code = """
try:
pass
except:
pass
else:
pass
# comment
call()
"""
assert dumps(parse(code)) == code
def test_comment_before_try():
code = """
try:
pass
except:
pass
# comment
try:
pass
except:
pass
"""
assert dumps(parse(code)) == code
def mutate(source, mutate_index, context):
"""
:param source: source code
:param mutate_index: the index of the mutation to be performed, if ALL mutates all available places
:return: tuple: mutated source code, number of mutations performed
"""
result = parse(source)
context = Context(mutate_index=mutate_index, **context)
context.pragma_no_mutate_lines = {
i + 1
for i, line in enumerate(source.split('\n'))
if '# pragma: no mutate' in line
} # lines are 1 based indexed
mutate_list_of_nodes(result, context=context)
result_source = dumps(result).replace(' not not ', ' ')
if context.performed_mutations:
assert source != result_source
return result_source, context.performed_mutations
def test_elif_with_empty_lines():
code = """
if cond:
pass
# ******************
# comment
# ******************
elif cond:
pass
# ****************
# comment
# ****************
else:
pass
"""
assert dumps(parse(code)) == code
def __repr__(self):
return repr(baron.dumps([self.fst()]))
def test_comment_in_middle_of_ifelseblock():
code = 'if a:\n pass\n# comment\nelse:\n pass\n'
assert dumps(parse(code)) == code
def test_regression_trailing_comment_after_colon_no_space_dump():
code = "def a():# pouf\n pass\n"
assert dumps(parse(code)) == code
def __repr__(self):
return repr(baron.dumps([self.fst()]))
def test_comment_in_middle_of_try():
code = 'try:\n pass\n# comment\nexcept:\n pass\n'
assert dumps(parse(code)) == code
def dumps(self):
return baron.dumps(self.fst())
def test_single_object():
assert baron.dumps({"type": "name", "value": "a"}) == "a"
def test_single_object():
assert baron.dumps({"type": "name", "value": "a"}) == "a"
def dumps(self):
return baron.dumps(self.fst())
