['else' ':' suite]
['finally' ':' suite] |
'finally' ':' suite))
-with_stmt: 'with' test [ with_var ] ':' suite
+with_stmt: 'with' with_item (',' with_item)* ':' suite
+with_item: test ['as' expr]
with_var: 'as' expr
# NB compile.c makes sure that the default except clause is last
except_clause: 'except' [test [(',' | 'as') test]]
"""
lineno = node.get_lineno()
for_output = node.clone()
- for_output.set_prefix("")
+ for_output.prefix = ""
msg = "Line %d: could not convert: %s"
self.log_message(msg % (lineno, for_output))
if reason:
if not isinstance(target, list):
target = [target]
if not isinstance(source, list):
- source.set_prefix(" ")
+ source.prefix = " "
source = [source]
return Node(syms.atom,
"""A function call"""
node = Node(syms.power, [func_name, ArgList(args)])
if prefix is not None:
- node.set_prefix(prefix)
+ node.prefix = prefix
return node
def Newline():
If test is None, the "if test" part is omitted.
"""
- xp.set_prefix("")
- fp.set_prefix(" ")
- it.set_prefix(" ")
+ xp.prefix = ""
+ fp.prefix = " "
+ it.prefix = " "
for_leaf = Leaf(token.NAME, "for")
- for_leaf.set_prefix(" ")
+ for_leaf.prefix = " "
in_leaf = Leaf(token.NAME, "in")
- in_leaf.set_prefix(" ")
+ in_leaf.prefix = " "
inner_args = [for_leaf, fp, in_leaf, it]
if test:
- test.set_prefix(" ")
+ test.prefix = " "
if_leaf = Leaf(token.NAME, "if")
- if_leaf.set_prefix(" ")
+ if_leaf.prefix = " "
inner_args.append(Node(syms.comp_if, [if_leaf, test]))
inner = Node(syms.listmaker, [xp, Node(syms.comp_for, inner_args)])
return Node(syms.atom,
func = results["func"]
args = results["args"]
kwds = results.get("kwds")
- prefix = node.get_prefix()
+ prefix = node.prefix
func = func.clone()
if (func.type not in (token.NAME, syms.atom) and
(func.type != syms.power or
func.children[-2].type == token.DOUBLESTAR)):
# Need to parenthesize
func = parenthesize(func)
- func.set_prefix("")
+ func.prefix = ""
args = args.clone()
- args.set_prefix("")
+ args.prefix = ""
if kwds is not None:
kwds = kwds.clone()
- kwds.set_prefix("")
+ kwds.prefix = ""
l_newargs = [pytree.Leaf(token.STAR, "*"), args]
if kwds is not None:
l_newargs.extend([Comma(),
pytree.Leaf(token.DOUBLESTAR, "**"),
kwds])
- l_newargs[-2].set_prefix(" ") # that's the ** token
+ l_newargs[-2].prefix = " " # that's the ** token
# XXX Sometimes we could be cleverer, e.g. apply(f, (x, y) + t)
# can be translated into f(x, y, *t) instead of f(*(x, y) + t)
#new = pytree.Node(syms.power, (func, ArgList(l_newargs)))
PATTERN = "'basestring'"
def transform(self, node, results):
- return Name("str", prefix=node.get_prefix())
+ return Name("str", prefix=node.prefix)
explicit = True # The user must ask for this fixer
PATTERN = """
- power< name='buffer' trailer< '(' [any] ')' > >
+ power< name='buffer' trailer< '(' [any] ')' > any* >
"""
def transform(self, node, results):
name = results["name"]
- name.replace(Name("memoryview", prefix=name.get_prefix()))
+ name.replace(Name("memoryview", prefix=name.prefix))
func = results["func"]
args = [func.clone(), String(', '), String("'__call__'")]
- return Call(Name("hasattr"), args, prefix=node.get_prefix())
+ return Call(Name("hasattr"), args, prefix=node.prefix)
args = head + [pytree.Node(syms.trailer,
[Dot(),
Name(method_name,
- prefix=method.get_prefix())]),
+ prefix=method.prefix)]),
results["parens"].clone()]
new = pytree.Node(syms.power, args)
if not special:
- new.set_prefix("")
+ new.prefix = ""
new = Call(Name(isiter and "iter" or "list"), [new])
if tail:
new = pytree.Node(syms.power, [new] + tail)
- new.set_prefix(node.get_prefix())
+ new.prefix = node.prefix
return new
P1 = "power< func=NAME trailer< '(' node=any ')' > any* >"
class FixExcept(fixer_base.BaseFix):
PATTERN = """
- try_stmt< 'try' ':' suite
- cleanup=(except_clause ':' suite)+
- tail=(['except' ':' suite]
- ['else' ':' suite]
- ['finally' ':' suite]) >
+ try_stmt< 'try' ':' (simple_stmt | suite)
+ cleanup=(except_clause ':' (simple_stmt | suite))+
+ tail=(['except' ':' (simple_stmt | suite)]
+ ['else' ':' (simple_stmt | suite)]
+ ['finally' ':' (simple_stmt | suite)]) >
"""
def transform(self, node, results):
# Generate a new N for the except clause
new_N = Name(self.new_name(), prefix=" ")
target = N.clone()
- target.set_prefix("")
+ target.prefix = ""
N.replace(new_N)
new_N = new_N.clone()
for child in reversed(suite_stmts[:i]):
e_suite.insert_child(0, child)
e_suite.insert_child(i, assign)
- elif N.get_prefix() == "":
+ elif N.prefix == "":
# No space after a comma is legal; no space after "as",
# not so much.
- N.set_prefix(" ")
+ N.prefix = " "
#TODO(cwinter) fix this when children becomes a smart list
children = [c.clone() for c in node.children[:3]] + try_cleanup + tail
b = results.get("b")
c = results.get("c")
args = [a.clone()]
- args[0].set_prefix("")
+ args[0].prefix = ""
if b is not None:
args.extend([Comma(), b.clone()])
if c is not None:
args.extend([Comma(), c.clone()])
- return Call(Name("exec"), args, prefix=node.get_prefix())
+ return Call(Name("exec"), args, prefix=node.prefix)
# Wrap the open call in a compile call. This is so the filename will be
# preserved in the execed code.
filename_arg = filename.clone()
- filename_arg.set_prefix(" ")
+ filename_arg.prefix = " "
exec_str = String("'exec'", " ")
compile_args = open_expr + [Comma(), filename_arg, Comma(), exec_str]
compile_call = Call(Name("compile"), compile_args, "")
args.extend([Comma(), globals.clone()])
if locals is not None:
args.extend([Comma(), locals.clone()])
- return Call(Name("exec"), args, prefix=node.get_prefix())
+ return Call(Name("exec"), args, prefix=node.prefix)
if in_special_context(node):
return None
new = node.clone()
- new.set_prefix("")
+ new.prefix = ""
new = Call(Name("list"), [new])
- new.set_prefix(node.get_prefix())
+ new.prefix = node.prefix
return new
def transform(self, node, results):
attr = results["attr"][0]
attr.replace(Name(("__%s__" % attr.value[5:]),
- prefix=attr.get_prefix()))
+ prefix=attr.prefix))
def transform(self, node, results):
new = BlankLine()
- new.prefix = node.get_prefix()
+ new.prefix = node.prefix
return new
def transform(self, node, results):
name = results["name"]
- name.replace(Name("getcwd", prefix=name.get_prefix()))
+ name.replace(Name("getcwd", prefix=name.prefix))
return None
negation = results.get("negation")
anchor = results["anchor"]
- prefix = node.get_prefix()
+ prefix = node.prefix
before = [n.clone() for n in results["before"]]
arg = results["arg"].clone()
after = results.get("after")
before = before[0]
else:
before = pytree.Node(syms.power, before)
- before.set_prefix(" ")
+ before.prefix = " "
n_op = Name("in", prefix=" ")
if negation:
n_not = Name("not", prefix=" ")
syms.arith_expr, syms.term,
syms.factor, syms.power):
new = parenthesize(new)
- new.set_prefix(prefix)
+ new.prefix = prefix
return new
def transform_isinstance(self, node, results):
x = results["x"].clone() # The thing inside of type()
T = results["T"].clone() # The type being compared against
- x.set_prefix("")
- T.set_prefix(" ")
+ x.prefix = ""
+ T.prefix = " "
test = Call(Name("isinstance"), [x, Comma(), T])
if "n" in results:
- test.set_prefix(" ")
+ test.prefix = " "
test = Node(syms.not_test, [Name("not"), test])
- test.set_prefix(node.get_prefix())
+ test.prefix = node.prefix
return test
def transform_while(self, node, results):
one = results["while"]
- one.replace(Name("True", prefix=one.get_prefix()))
+ one.replace(Name("True", prefix=one.prefix))
def transform_sort(self, node, results):
sort_stmt = results["sort"]
simple_expr = results.get("expr")
if list_call:
- list_call.replace(Name("sorted", prefix=list_call.get_prefix()))
+ list_call.replace(Name("sorted", prefix=list_call.prefix))
elif simple_expr:
new = simple_expr.clone()
- new.set_prefix("")
+ new.prefix = ""
simple_expr.replace(Call(Name("sorted"), [new],
- prefix=simple_expr.get_prefix()))
+ prefix=simple_expr.prefix))
else:
raise RuntimeError("should not have reached here")
sort_stmt.remove()
if next_stmt:
- next_stmt[0].set_prefix(sort_stmt.get_prefix())
+ next_stmt[0].prefix = sort_stmt.prefix
return
new = FromImport('.', [imp])
- new.set_prefix(node.get_prefix())
+ new.prefix = node.prefix
return new
def probably_a_local_import(self, imp_name):
if import_mod:
mod_name = import_mod.value
new_name = self.mapping[mod_name]
- import_mod.replace(Name(new_name, prefix=import_mod.get_prefix()))
+ import_mod.replace(Name(new_name, prefix=import_mod.prefix))
if "name_import" in results:
# If it's not a "from x import x, y" or "import x as y" import,
# marked its usage to be replaced.
bare_name = results["bare_with_attr"][0]
new_name = self.replace.get(bare_name.value)
if new_name:
- bare_name.replace(Name(new_name, prefix=bare_name.get_prefix()))
+ bare_name.replace(Name(new_name, prefix=bare_name.prefix))
return
new = node.clone()
- new.set_prefix("")
- return Call(Name("eval"), [new], prefix=node.get_prefix())
+ new.prefix = ""
+ return Call(Name("eval"), [new], prefix=node.prefix)
[results["lpar"].clone(),
newarglist,
results["rpar"].clone()])] + after)
- new.set_prefix(node.get_prefix())
+ new.prefix = node.prefix
touch_import(None, 'sys', node)
return new
del new_args[-1]
if len(new_args) == 1:
atom = testlist.parent
- new_args[0].set_prefix(atom.get_prefix())
+ new_args[0].prefix = atom.prefix
atom.replace(new_args[0])
else:
args[:] = new_args
if 'it' in results and func.value != 'ifilterfalse':
dot, it = (results['dot'], results['it'])
# Remove the 'itertools'
- prefix = it.get_prefix()
+ prefix = it.prefix
it.remove()
# Replace the node wich contains ('.', 'function') with the
# function (to be consistant with the second part of the pattern)
dot.remove()
func.parent.replace(func)
- prefix = prefix or func.get_prefix()
+ prefix = prefix or func.prefix
func.replace(Name(func.value[1:], prefix=prefix))
# If there are no imports left, just get rid of the entire statement
if not (imports.children or getattr(imports, 'value', None)) or \
imports.parent is None:
- p = node.get_prefix()
+ p = node.prefix
node = BlankLine()
node.prefix = p
return node
def transform(self, node, results):
if is_probably_builtin(node):
new = self.static_int.clone()
- new.set_prefix(node.get_prefix())
+ new.prefix = node.prefix
return new
if node.parent.type == syms.simple_stmt:
self.warning(node, "You should use a for loop here")
new = node.clone()
- new.set_prefix("")
+ new.prefix = ""
new = Call(Name("list"), [new])
elif "map_lambda" in results:
new = ListComp(results.get("xp").clone(),
if in_special_context(node):
return None
new = node.clone()
- new.set_prefix("")
+ new.prefix = ""
new = Call(Name("list"), [new])
- new.set_prefix(node.get_prefix())
+ new.prefix = node.prefix
return new
parent.insert_child(i, new_stmt)
new_leaf1 = new_stmt.children[0].children[0]
old_leaf1 = stmt_node.children[0].children[0]
- new_leaf1.set_prefix(old_leaf1.get_prefix())
+ new_leaf1.prefix = old_leaf1.prefix
def remove_trailing_newline(node):
node = kids.pop()
if isinstance(node, Leaf) and node.type != token.DEDENT:
if node.prefix:
- node.set_prefix('')
+ node.prefix = ''
return
else:
kids.extend(node.children[::-1])
# now stick the metaclass in the arglist
meta_txt = last_metaclass.children[0].children[0]
meta_txt.value = 'metaclass'
- orig_meta_prefix = meta_txt.get_prefix()
+ orig_meta_prefix = meta_txt.prefix
if arglist.children:
arglist.append_child(Leaf(token.COMMA, ','))
- meta_txt.set_prefix(' ')
+ meta_txt.prefix = ' '
else:
- meta_txt.set_prefix('')
+ meta_txt.prefix = ''
# compact the expression "metaclass = Meta" -> "metaclass=Meta"
expr_stmt = last_metaclass.children[0]
assert expr_stmt.type == syms.expr_stmt
- expr_stmt.children[1].set_prefix('')
- expr_stmt.children[2].set_prefix('')
+ expr_stmt.children[1].prefix = ''
+ expr_stmt.children[2].prefix = ''
arglist.append_child(last_metaclass)
# one-liner that was just __metaclass_
suite.remove()
pass_leaf = Leaf(text_type, 'pass')
- pass_leaf.set_prefix(orig_meta_prefix)
+ pass_leaf.prefix = orig_meta_prefix
node.append_child(pass_leaf)
node.append_child(Leaf(token.NEWLINE, '\n'))
def transform(self, node, results):
attr = results["attr"][0]
new = MAP[attr.value]
- attr.replace(Name(new, prefix=attr.get_prefix()))
+ attr.replace(Name(new, prefix=attr.prefix))
return node.type == token.NOTEQUAL and node.value == "<>"
def transform(self, node, results):
- new = pytree.Leaf(token.NOTEQUAL, "!=")
- new.set_prefix(node.get_prefix())
+ new = pytree.Leaf(token.NOTEQUAL, "!=", prefix=node.prefix)
return new
base = results.get("base")
attr = results.get("attr")
name = results.get("name")
- mod = results.get("mod")
if base:
if self.shadowed_next:
- attr.replace(Name("__next__", prefix=attr.get_prefix()))
+ attr.replace(Name("__next__", prefix=attr.prefix))
else:
base = [n.clone() for n in base]
- base[0].set_prefix("")
- node.replace(Call(Name("next", prefix=node.get_prefix()), base))
+ base[0].prefix = ""
+ node.replace(Call(Name("next", prefix=node.prefix), base))
elif name:
- n = Name("__next__", prefix=name.get_prefix())
+ n = Name("__next__", prefix=name.prefix)
name.replace(n)
elif attr:
# We don't do this transformation if we're assigning to "x.next".
def transform(self, node, results):
name = results["name"]
- new = Name("__bool__", prefix=name.get_prefix())
+ new = Name("__bool__", prefix=name.prefix)
name.replace(new)
elif val.startswith('0') and val.isdigit() and len(set(val)) > 1:
val = "0o" + val[1:]
- return Number(val, prefix=node.get_prefix())
+ return Number(val, prefix=node.prefix)
target = results["target"]
lparen = LParen()
- lparen.set_prefix(target.get_prefix())
- target.set_prefix("") # Make it hug the parentheses
+ lparen.prefix = target.prefix
+ target.prefix = "" # Make it hug the parentheses
target.insert_child(0, lparen)
target.append_child(RParen())
if bare_print:
# Special-case print all by itself
bare_print.replace(Call(Name("print"), [],
- prefix=bare_print.get_prefix()))
+ prefix=bare_print.prefix))
return
assert node.children[0] == Name("print")
args = node.children[1:]
# Now synthesize a print(args, sep=..., end=..., file=...) node.
l_args = [arg.clone() for arg in args]
if l_args:
- l_args[0].set_prefix("")
+ l_args[0].prefix = ""
if sep is not None or end is not None or file is not None:
if sep is not None:
self.add_kwarg(l_args, "sep", String(repr(sep)))
if file is not None:
self.add_kwarg(l_args, "file", file)
n_stmt = Call(Name("print"), l_args)
- n_stmt.set_prefix(node.get_prefix())
+ n_stmt.prefix = node.prefix
return n_stmt
def add_kwarg(self, l_nodes, s_kwd, n_expr):
# XXX All this prefix-setting may lose comments (though rarely)
- n_expr.set_prefix("")
+ n_expr.prefix = ""
n_argument = pytree.Node(self.syms.argument,
(Name(s_kwd),
pytree.Leaf(token.EQUAL, "="),
n_expr))
if l_nodes:
l_nodes.append(Comma())
- n_argument.set_prefix(" ")
+ n_argument.prefix = " "
l_nodes.append(n_argument)
# exc.children[1:-1] is the unparenthesized tuple
# exc.children[1].children[0] is the first element of the tuple
exc = exc.children[1].children[0].clone()
- exc.set_prefix(" ")
+ exc.prefix = " "
if "val" not in results:
# One-argument raise
new = pytree.Node(syms.raise_stmt, [Name("raise"), exc])
- new.set_prefix(node.get_prefix())
+ new.prefix = node.prefix
return new
val = results["val"].clone()
if is_tuple(val):
args = [c.clone() for c in val.children[1:-1]]
else:
- val.set_prefix("")
+ val.prefix = ""
args = [val]
if "tb" in results:
tb = results["tb"].clone()
- tb.set_prefix("")
+ tb.prefix = ""
e = Call(exc, args)
with_tb = Attr(e, Name('with_traceback')) + [ArgList([tb])]
new = pytree.Node(syms.simple_stmt, [Name("raise")] + with_tb)
- new.set_prefix(node.get_prefix())
+ new.prefix = node.prefix
return new
else:
return pytree.Node(syms.raise_stmt,
[Name("raise"), Call(exc, args)],
- prefix=node.get_prefix())
+ prefix=node.prefix)
def transform(self, node, results):
name = results["name"]
- name.replace(Name("input", prefix=name.get_prefix()))
+ name.replace(Name("input", prefix=name.prefix))
if mod_name and attr_name:
new_attr = LOOKUP[(mod_name.value, attr_name.value)]
- attr_name.replace(Name(new_attr, prefix=attr_name.get_prefix()))
+ attr_name.replace(Name(new_attr, prefix=attr_name.prefix))
if expr.type == self.syms.testlist1:
expr = parenthesize(expr)
- return Call(Name("repr"), [expr], prefix=node.get_prefix())
+ return Call(Name("repr"), [expr], prefix=node.prefix)
literal.extend(n.clone() for n in items.children)
literal.append(pytree.Leaf(token.RBRACE, "}"))
# Set the prefix of the right brace to that of the ')' or ']'
- literal[-1].set_prefix(items.next_sibling.get_prefix())
+ literal[-1].prefix = items.next_sibling.prefix
maker = pytree.Node(syms.dictsetmaker, literal)
- maker.set_prefix(node.get_prefix())
+ 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].set_prefix(n.get_prefix())
+ maker.children[-1].prefix = n.prefix
# Finally, replace the set call with our shiny new literal.
return maker
"""
def transform(self, node, results):
- return Name("Exception", prefix=node.get_prefix())
+ return Name("Exception", prefix=node.prefix)
sys_attr = results["attribute"][0]
index = Number(self.exc_info.index(sys_attr.value))
- call = Call(Name("exc_info"), prefix=sys_attr.get_prefix())
+ call = Call(Name("exc_info"), prefix=sys_attr.prefix)
attr = Attr(Name("sys"), call)
- attr[1].children[0].set_prefix(results["dot"].get_prefix())
+ attr[1].children[0].prefix = results["dot"].prefix
attr.append(Subscript(index))
- return Node(syms.power, attr, prefix=node.get_prefix())
+ return Node(syms.power, attr, prefix=node.prefix)
if is_tuple(val):
args = [c.clone() for c in val.children[1:-1]]
else:
- val.set_prefix("")
+ val.prefix = ""
args = [val]
throw_args = results["args"]
if "tb" in results:
tb = results["tb"].clone()
- tb.set_prefix("")
+ tb.prefix = ""
e = Call(exc, args)
with_tb = Attr(e, Name('with_traceback')) + [ArgList([tb])]
def handle_tuple(tuple_arg, add_prefix=False):
n = Name(self.new_name())
arg = tuple_arg.clone()
- arg.set_prefix("")
+ arg.prefix = ""
stmt = Assign(arg, n.clone())
if add_prefix:
- n.set_prefix(" ")
+ n.prefix = " "
tuple_arg.replace(n)
new_lines.append(pytree.Node(syms.simple_stmt,
[stmt, end.clone()]))
# TODO(cwinter) suite-cleanup
after = start
if start == 0:
- new_lines[0].set_prefix(" ")
+ new_lines[0].prefix = " "
elif is_docstring(suite[0].children[start]):
- new_lines[0].set_prefix(indent)
+ new_lines[0].prefix = indent
after = start + 1
suite[0].children[after:after] = new_lines
for i in range(after+1, after+len(new_lines)+1):
- suite[0].children[i].set_prefix(indent)
+ suite[0].children[i].prefix = indent
suite[0].changed()
def transform_lambda(self, node, results):
# Replace lambda ((((x)))): x with lambda x: x
if inner.type == token.NAME:
inner = inner.clone()
- inner.set_prefix(" ")
+ inner.prefix = " "
args.replace(inner)
return
subscripts = [c.clone() for c in to_index[n.value]]
new = pytree.Node(syms.power,
[new_param.clone()] + subscripts)
- new.set_prefix(n.get_prefix())
+ new.prefix = n.prefix
n.replace(new)
def transform(self, node, results):
new_value = _TYPE_MAPPING.get(results["name"].value)
if new_value:
- return Name(new_value, prefix=node.get_prefix())
+ return Name(new_value, prefix=node.prefix)
return None
from ..pgen2 import token
from .. import fixer_base
+_mapping = {"unichr" : "chr", "unicode" : "str"}
+_literal_re = re.compile(r"[uU][rR]?[\'\"]")
+
class FixUnicode(fixer_base.BaseFix):
- PATTERN = "STRING | NAME<'unicode' | 'unichr'>"
+ PATTERN = "STRING | 'unicode' | 'unichr'"
def transform(self, node, results):
if node.type == token.NAME:
- if node.value == "unicode":
- new = node.clone()
- new.value = "str"
- return new
- if node.value == "unichr":
- new = node.clone()
- new.value = "chr"
- return new
- # XXX Warn when __unicode__ found?
+ new = node.clone()
+ new.value = _mapping[node.value]
+ return new
elif node.type == token.STRING:
- if re.match(r"[uU][rR]?[\'\"]", node.value):
+ if _literal_re.match(node.value):
new = node.clone()
new.value = new.value[1:]
return new
replacements.
"""
import_mod = results.get('module')
- pref = import_mod.get_prefix()
+ pref = import_mod.prefix
names = []
module.
"""
mod_member = results.get('mod_member')
- pref = mod_member.get_prefix()
+ pref = mod_member.prefix
member = results.get('member')
# Simple case with only a single member being imported
break
if new_name:
module_dot.replace(Name(new_name,
- prefix=module_dot.get_prefix()))
+ prefix=module_dot.prefix))
else:
self.cannot_convert(node, 'This is an invalid module element')
comma = False
for child in new.children:
if child in self.SEPS:
- prefix = child.get_prefix()
+ prefix = child.prefix
if prefix.isspace() and "\n" not in prefix:
- child.set_prefix("")
+ child.prefix = ""
comma = True
else:
if comma:
- prefix = child.get_prefix()
+ prefix = child.prefix
if not prefix:
- child.set_prefix(" ")
+ child.prefix = " "
comma = False
return new
def transform_xrange(self, node, results):
name = results["name"]
- name.replace(Name("range", prefix=name.get_prefix()))
+ name.replace(Name("range", prefix=name.prefix))
def transform_range(self, node, results):
if not self.in_special_context(node):
range_call = Call(Name("range"), [results["args"].clone()])
# Encase the range call in list().
list_call = Call(Name("list"), [range_call],
- prefix=node.get_prefix())
+ prefix=node.prefix)
# Put things that were after the range() call after the list call.
for n in results["rest"]:
list_call.append_child(n)
no_call = results.get("no_call")
if no_call:
- no_call.replace(Name("__iter__", prefix=no_call.get_prefix()))
+ no_call.replace(Name("__iter__", prefix=no_call.prefix))
else:
node.replace([x.clone() for x in results["call"]])
return None
new = node.clone()
- new.set_prefix("")
+ new.prefix = ""
new = Call(Name("list"), [new])
- new.set_prefix(node.get_prefix())
+ new.prefix = node.prefix
return new
import os
# Fairly local imports
-from .pgen2 import driver
-from .pgen2 import literals
-from .pgen2 import token
-from .pgen2 import tokenize
+from .pgen2 import driver, literals, token, tokenize, parse
# Really local imports
from . import pytree
"PatternGrammar.txt")
+class PatternSyntaxError(Exception):
+ pass
+
+
def tokenize_wrapper(input):
"""Tokenizes a string suppressing significant whitespace."""
skip = set((token.NEWLINE, token.INDENT, token.DEDENT))
def compile_pattern(self, input, debug=False):
"""Compiles a pattern string to a nested pytree.*Pattern object."""
tokens = tokenize_wrapper(input)
- root = self.driver.parse_tokens(tokens, debug=debug)
+ try:
+ root = self.driver.parse_tokens(tokens, debug=debug)
+ except parse.ParseError as e:
+ raise PatternSyntaxError(str(e))
return self.compile_node(root)
def compile_node(self, node):
value = node.value
if value.isupper():
if value not in TOKEN_MAP:
- raise SyntaxError("Invalid token: %r" % value)
+ raise PatternSyntaxError("Invalid token: %r" % value)
+ if nodes[1:]:
+ raise PatternSyntaxError("Can't have details for token")
return pytree.LeafPattern(TOKEN_MAP[value])
else:
if value == "any":
elif not value.startswith("_"):
type = getattr(self.pysyms, value, None)
if type is None:
- raise SyntaxError("Invalid symbol: %r" % value)
+ raise PatternSyntaxError("Invalid symbol: %r" % value)
if nodes[1:]: # Details present
content = [self.compile_node(nodes[1].children[1])]
else:
__author__ = "Guido van Rossum <guido@python.org>"
import sys
+import warnings
from io import StringIO
"""
Set the prefix for the node (see Leaf class).
- This must be implemented by the concrete subclass.
+ DEPRECATED; use the prefix property directly.
"""
- raise NotImplementedError
+ warnings.warn("set_prefix() is deprecated; use the prefix property",
+ DeprecationWarning, stacklevel=2)
+ self.prefix = prefix
def get_prefix(self):
"""
Return the prefix for the node (see Leaf class).
- This must be implemented by the concrete subclass.
+ DEPRECATED; use the prefix property directly.
"""
- raise NotImplementedError
+ warnings.warn("get_prefix() is deprecated; use the prefix property",
+ DeprecationWarning, stacklevel=2)
+ return self.prefix
def replace(self, new):
"""Replace this node with a new one in the parent."""
def get_suffix(self):
"""
Return the string immediately following the invocant node. This is
- effectively equivalent to node.next_sibling.get_prefix()
+ effectively equivalent to node.next_sibling.prefix
"""
next_sib = self.next_sibling
if next_sib is None:
return ""
- return next_sib.get_prefix()
+ return next_sib.prefix
if sys.version_info < (3, 0):
def __str__(self):
assert ch.parent is None, repr(ch)
ch.parent = self
if prefix is not None:
- self.set_prefix(prefix)
+ self.prefix = prefix
def __repr__(self):
"""Return a canonical string representation."""
for node in child.post_order():
yield node
- def set_prefix(self, prefix):
- """
- Set the prefix for the node.
-
- This passes the responsibility on to the first child.
- """
- if self.children:
- self.children[0].set_prefix(prefix)
-
- def get_prefix(self):
+ @property
+ def prefix(self):
"""
- Return the prefix for the node.
-
- This passes the call on to the first child.
+ The whitespace and comments preceding this node in the input.
"""
if not self.children:
return ""
- return self.children[0].get_prefix()
+ return self.children[0].prefix
+
+ @prefix.setter
+ def prefix(self, prefix):
+ if self.children:
+ self.children[0].prefix = prefix
def set_child(self, i, child):
"""
"""Concrete implementation for leaf nodes."""
# Default values for instance variables
- prefix = "" # Whitespace and comments preceding this token in the input
- lineno = 0 # Line where this token starts in the input
- column = 0 # Column where this token tarts in the input
+ _prefix = "" # Whitespace and comments preceding this token in the input
+ lineno = 0 # Line where this token starts in the input
+ column = 0 # Column where this token tarts in the input
def __init__(self, type, value, context=None, prefix=None):
"""
"""
assert 0 <= type < 256, type
if context is not None:
- self.prefix, (self.lineno, self.column) = context
+ self._prefix, (self.lineno, self.column) = context
self.type = type
self.value = value
if prefix is not None:
- self.prefix = prefix
+ self._prefix = prefix
def __repr__(self):
"""Return a canonical string representation."""
"""Return a pre-order iterator for the tree."""
yield self
- def set_prefix(self, prefix):
- """Set the prefix for the node."""
- self.changed()
- self.prefix = prefix
+ @property
+ def prefix(self):
+ """
+ The whitespace and comments preceding this token in the input.
+ """
+ return self._prefix
- def get_prefix(self):
- """Return the prefix for the node."""
- return self.prefix
+ @prefix.setter
+ def prefix(self, prefix):
+ self.changed()
+ self._prefix = prefix
def convert(gr, raw_node):
-#!/usr/bin/env python2.5
# Copyright 2006 Google, Inc. All Rights Reserved.
# Licensed to PSF under a Contributor Agreement.
# Local imports
from .pgen2 import driver, tokenize
-
-from . import pytree
-from . import patcomp
-from . import fixes
-from . import pygram
+from . import pytree, pygram
def get_all_fix_names(fixer_pkg, remove_prefix=True):
#!/usr/bin/env python
# -*- coding: iso-8859-1 -*-
-print(u'ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ')
-
+print u'ßàáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞ'
def transform(self, node, results):
name = results["name"]
- name.replace(Name("cheese", name.get_prefix()))
+ name.replace(Name("cheese", name.prefix))
-# Python 2's Lib/test/test_grammar.py (r66189)
-
# Python test set -- part 1, grammar.
# This just tests whether the parser accepts them all.
self.assertEqual([x for x, in [(4,), (5,), (6,)]], [4, 5, 6])
self.assertEqual(list(x for x, in [(7,), (8,), (9,)]), [7, 8, 9])
+ def test_with_statement(self):
+ class manager(object):
+ def __enter__(self):
+ return (1, 2)
+ def __exit__(self, *args):
+ pass
+
+ with manager():
+ pass
+ with manager() as x:
+ pass
+ with manager() as (x, y):
+ pass
+ with manager(), manager():
+ pass
+ with manager() as x, manager() as y:
+ pass
+ with manager() as x, manager():
+ pass
+
def testIfElseExpr(self):
# Test ifelse expressions in various cases
def _checkeval(msg, ret):
self.assertEqual([x for x, in [(4,), (5,), (6,)]], [4, 5, 6])
self.assertEqual(list(x for x, in [(7,), (8,), (9,)]), [7, 8, 9])
+ def test_with_statement(self):
+ class manager(object):
+ def __enter__(self):
+ return (1, 2)
+ def __exit__(self, *args):
+ pass
+
+ with manager():
+ pass
+ with manager() as x:
+ pass
+ with manager() as (x, y):
+ pass
+ with manager(), manager():
+ pass
+ with manager() as x, manager() as y:
+ pass
+ with manager() as x, manager():
+ pass
+
def testIfElseExpr(self):
# Test ifelse expressions in various cases
def _checkeval(msg, ret):
-#!/usr/bin/env python2.5
+#!/usr/bin/env python
# Copyright 2006 Google, Inc. All Rights Reserved.
# Licensed to PSF under a Contributor Agreement.
def reformat(string):
return dedent(string) + "\n\n"
-def get_refactorer(fixers=None, options=None):
+def get_refactorer(fixer_pkg="lib2to3", fixers=None, options=None):
"""
A convenience function for creating a RefactoringTool for tests.
be passed to the RefactoringTool.
"""
if fixers is not None:
- fixers = ["lib2to3.fixes.fix_" + fix for fix in fixers]
+ fixers = [fixer_pkg + ".fixes.fix_" + fix for fix in fixers]
else:
- fixers = refactor.get_fixers_from_package("lib2to3.fixes")
+ fixers = refactor.get_fixers_from_package(fixer_pkg + ".fixes")
options = options or {}
return refactor.RefactoringTool(fixers, options, explicit=True)
-#!/usr/bin/env python2.5
"""Tests that run all fixer modules over an input stream.
This has been broken out into its own test module because of its
"""
# Author: Collin Winter
-# Testing imports
-try:
- from . import support
-except ImportError:
- import support
-
# Python imports
import unittest
# Local imports
from .. import pytree
from .. import refactor
+from . import support
class Test_all(support.TestCase):
for filepath in support.all_project_files():
print("Fixing %s..." % filepath)
self.refactor.refactor_file(filepath)
-
-
-if __name__ == "__main__":
- import __main__
- support.run_all_tests(__main__)
-#!/usr/bin/env python2.5
""" Test suite for the fixer modules """
-# Author: Collin Winter
-
-# Testing imports
-try:
- from tests import support
-except ImportError:
- from . import support
# Python imports
import os
# Local imports
from lib2to3 import pygram, pytree, refactor, fixer_util
+from lib2to3.tests import support
class FixerTestCase(support.TestCase):
- def setUp(self, fix_list=None):
+
+ # Other test cases can subclass this class and replace "fixer_pkg" with
+ # their own.
+ def setUp(self, fix_list=None, fixer_pkg="lib2to3", options=None):
if fix_list is None:
fix_list = [self.fixer]
- options = {"print_function" : False}
- self.refactor = support.get_refactorer(fix_list, options)
+ if options is None:
+ options = {"print_function" : False}
+ self.refactor = support.get_refactorer(fixer_pkg, fix_list, options)
self.fixer_log = []
self.filename = "<string>"
fixes = [self.fixer]
fixes.extend(names)
options = {"print_function" : False}
- r = support.get_refactorer(fixes, options)
+ r = support.get_refactorer("lib2to3", fixes, options)
(pre, post) = r.get_fixers()
n = "fix_" + self.fixer
if post and post[-1].__class__.__module__.endswith(n):
def test_5(self):
b = """print; print whatever;"""
a = """print(); print(whatever);"""
+ self.check(b, a)
def test_tuple(self):
b = """print (a, b, c)"""
pass"""
self.check(b, a)
+ def test_one_line_suites(self):
+ b = """
+ try: raise TypeError
+ except TypeError, e:
+ pass
+ """
+ a = """
+ try: raise TypeError
+ except TypeError as e:
+ pass
+ """
+ self.check(b, a)
+ b = """
+ try:
+ raise TypeError
+ except TypeError, e: pass
+ """
+ a = """
+ try:
+ raise TypeError
+ except TypeError as e: pass
+ """
+ self.check(b, a)
+ b = """
+ try: raise TypeError
+ except TypeError, e: pass
+ """
+ a = """
+ try: raise TypeError
+ except TypeError as e: pass
+ """
+ self.check(b, a)
+ b = """
+ try: raise TypeError
+ except TypeError, e: pass
+ else: function()
+ finally: done()
+ """
+ a = """
+ try: raise TypeError
+ except TypeError as e: pass
+ else: function()
+ finally: done()
+ """
+ self.check(b, a)
+
# These should not be touched:
def test_unchanged_1(self):
class Test_unicode(FixerTestCase):
fixer = "unicode"
+ def test_whitespace(self):
+ b = """unicode( x)"""
+ a = """str( x)"""
+ self.check(b, a)
+
+ b = """ unicode(x )"""
+ a = """ str(x )"""
+ self.check(b, a)
+
+ b = """ u'h'"""
+ a = """ 'h'"""
+ self.check(b, a)
+
def test_unicode_call(self):
b = """unicode(x, y, z)"""
a = """str(x, y, z)"""
self.check(b, a)
+ def test_unichr(self):
+ b = """unichr(u'h')"""
+ a = """chr('h')"""
+ self.check(b, a)
+
def test_unicode_literal_1(self):
b = '''u"x"'''
a = '''"x"'''
self.check(b, a)
def test_unicode_literal_3(self):
- b = """UR'''x'''"""
- a = """R'''x'''"""
+ b = """UR'''x''' """
+ a = """R'''x''' """
self.check(b, a)
class Test_callable(FixerTestCase):
a = """x = memoryview(y)"""
self.check(b, a)
+ def test_slicing(self):
+ b = """buffer(y)[4:5]"""
+ a = """memoryview(y)[4:5]"""
+ self.check(b, a)
+
class Test_future(FixerTestCase):
fixer = "future"
b = """os.getcwdu ( )"""
a = """os.getcwd ( )"""
self.check(b, a)
-
-
-if __name__ == "__main__":
- import __main__
- support.run_all_tests(__main__)
-#!/usr/bin/env python2.5
"""Test suite for 2to3's parser and grammar files.
This is the place to add tests for changes to 2to3's grammar, such as those
parts of the grammar we've changed, we also make sure we can parse the
test_grammar.py files from both Python 2 and Python 3.
"""
-# Author: Collin Winter
# Testing imports
from . import support
def diff(fn, result):
- f = open("@", "w")
+ f = open("@", "wb")
try:
f.write(result)
finally:
return os.system("diff -u %s @" % fn)
finally:
os.remove("@")
-
-
-if __name__ == "__main__":
- import __main__
- support.run_all_tests(__main__)
-#!/usr/bin/env python2.5
# Copyright 2006 Google, Inc. All Rights Reserved.
# Licensed to PSF under a Contributor Agreement.
especially when debugging a test.
"""
+import warnings
+
# Testing imports
from . import support
-# Local imports (XXX should become a package)
-from .. import pytree
+from lib2to3 import pytree
try:
sorted
"""Unit tests for nodes (Base, Leaf, Node)."""
- def testBaseCantConstruct(self):
+ def test_deprecated_prefix_methods(self):
+ l = pytree.Leaf(100, "foo")
+ with warnings.catch_warnings(record=True) as w:
+ self.assertEqual(l.get_prefix(), "")
+ l.set_prefix("hi")
+ self.assertEqual(l.prefix, "hi")
+ self.assertEqual(len(w), 2)
+ for warning in w:
+ self.assertTrue(warning.category is DeprecationWarning)
+ self.assertEqual(str(w[0].message), "get_prefix() is deprecated; " \
+ "use the prefix property")
+ self.assertEqual(str(w[1].message), "set_prefix() is deprecated; " \
+ "use the prefix property")
+
+ def test_instantiate_base(self):
if __debug__:
# Test that instantiating Base() raises an AssertionError
self.assertRaises(AssertionError, pytree.Base)
- def testLeaf(self):
+ def test_leaf(self):
l1 = pytree.Leaf(100, "foo")
self.assertEqual(l1.type, 100)
self.assertEqual(l1.value, "foo")
- def testLeafRepr(self):
+ def test_leaf_repr(self):
l1 = pytree.Leaf(100, "foo")
self.assertEqual(repr(l1), "Leaf(100, 'foo')")
- def testLeafStr(self):
+ def test_leaf_str(self):
l1 = pytree.Leaf(100, "foo")
self.assertEqual(str(l1), "foo")
l2 = pytree.Leaf(100, "foo", context=(" ", (10, 1)))
self.assertEqual(str(l2), " foo")
- def testLeafStrNumericValue(self):
+ def test_leaf_str_numeric_value(self):
# Make sure that the Leaf's value is stringified. Failing to
# do this can cause a TypeError in certain situations.
l1 = pytree.Leaf(2, 5)
- l1.set_prefix("foo_")
+ l1.prefix = "foo_"
self.assertEqual(str(l1), "foo_5")
- def testLeafEq(self):
+ def test_leaf_equality(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "foo", context=(" ", (1, 0)))
self.assertEqual(l1, l2)
self.assertNotEqual(l1, l3)
self.assertNotEqual(l1, l4)
- def testLeafPrefix(self):
+ def test_leaf_prefix(self):
l1 = pytree.Leaf(100, "foo")
- self.assertEqual(l1.get_prefix(), "")
+ self.assertEqual(l1.prefix, "")
self.failIf(l1.was_changed)
- l1.set_prefix(" ##\n\n")
- self.assertEqual(l1.get_prefix(), " ##\n\n")
+ l1.prefix = " ##\n\n"
+ self.assertEqual(l1.prefix, " ##\n\n")
self.failUnless(l1.was_changed)
- def testNode(self):
+ def test_node(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(200, "bar")
n1 = pytree.Node(1000, [l1, l2])
self.assertEqual(n1.type, 1000)
self.assertEqual(n1.children, [l1, l2])
- def testNodeRepr(self):
+ def test_node_repr(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "bar", context=(" ", (1, 0)))
n1 = pytree.Node(1000, [l1, l2])
self.assertEqual(repr(n1),
"Node(1000, [%s, %s])" % (repr(l1), repr(l2)))
- def testNodeStr(self):
+ def test_node_str(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "bar", context=(" ", (1, 0)))
n1 = pytree.Node(1000, [l1, l2])
self.assertEqual(str(n1), "foo bar")
- def testNodePrefix(self):
+ def test_node_prefix(self):
l1 = pytree.Leaf(100, "foo")
- self.assertEqual(l1.get_prefix(), "")
+ self.assertEqual(l1.prefix, "")
n1 = pytree.Node(1000, [l1])
- self.assertEqual(n1.get_prefix(), "")
- n1.set_prefix(" ")
- self.assertEqual(n1.get_prefix(), " ")
- self.assertEqual(l1.get_prefix(), " ")
+ self.assertEqual(n1.prefix, "")
+ n1.prefix = " "
+ self.assertEqual(n1.prefix, " ")
+ self.assertEqual(l1.prefix, " ")
- def testGetSuffix(self):
+ 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.get_prefix())
+ 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.get_prefix())
+ self.assertEqual(n1.get_suffix(), l3.prefix)
self.assertEqual(l3.get_suffix(), "")
self.assertEqual(n2.get_suffix(), "")
- def testNodeEq(self):
+ def test_node_equality(self):
n1 = pytree.Node(1000, ())
n2 = pytree.Node(1000, [], context=(" ", (1, 0)))
self.assertEqual(n1, n2)
n3 = pytree.Node(1001, ())
self.assertNotEqual(n1, n3)
- def testNodeEqRecursive(self):
+ def test_node_recursive_equality(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "foo")
n1 = pytree.Node(1000, [l1])
n3 = pytree.Node(1000, [l3])
self.assertNotEqual(n1, n3)
- def testReplace(self):
+ def test_replace(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "+")
l3 = pytree.Leaf(100, "bar")
self.failUnless(isinstance(n1.children, list))
self.failUnless(n1.was_changed)
- def testReplaceWithList(self):
+ def test_replace_with_list(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "+")
l3 = pytree.Leaf(100, "bar")
self.assertEqual(str(n1), "foo**bar")
self.failUnless(isinstance(n1.children, list))
- def testPostOrder(self):
+ def test_post_order(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "bar")
n1 = pytree.Node(1000, [l1, l2])
self.assertEqual(list(n1.post_order()), [l1, l2, n1])
- def testPreOrder(self):
+ def test_pre_order(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "bar")
n1 = pytree.Node(1000, [l1, l2])
self.assertEqual(list(n1.pre_order()), [n1, l1, l2])
- def testChangedLeaf(self):
+ def test_changed(self):
l1 = pytree.Leaf(100, "f")
self.failIf(l1.was_changed)
-
l1.changed()
self.failUnless(l1.was_changed)
- def testChangedNode(self):
l1 = pytree.Leaf(100, "f")
n1 = pytree.Node(1000, [l1])
self.failIf(n1.was_changed)
-
n1.changed()
self.failUnless(n1.was_changed)
- def testChangedRecursive(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "+")
l3 = pytree.Leaf(100, "bar")
self.failUnless(n2.was_changed)
self.failIf(l1.was_changed)
- def testLeafConstructorPrefix(self):
+ def test_leaf_constructor_prefix(self):
for prefix in ("xyz_", ""):
l1 = pytree.Leaf(100, "self", prefix=prefix)
self.failUnless(str(l1), prefix + "self")
- self.assertEqual(l1.get_prefix(), prefix)
+ self.assertEqual(l1.prefix, prefix)
- def testNodeConstructorPrefix(self):
+ 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.failUnless(str(n1), prefix + "self_foo")
- self.assertEqual(n1.get_prefix(), prefix)
- self.assertEqual(l1.get_prefix(), prefix)
- self.assertEqual(l2.get_prefix(), "_")
+ self.assertEqual(n1.prefix, prefix)
+ self.assertEqual(l1.prefix, prefix)
+ self.assertEqual(l2.prefix, "_")
- def testRemove(self):
+ def test_remove(self):
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "foo")
n1 = pytree.Node(1000, [l1, l2])
self.failUnless(n1.was_changed)
self.failUnless(n2.was_changed)
- def testRemoveParentless(self):
+ def test_remove_parentless(self):
n1 = pytree.Node(1000, [])
n1.remove()
self.assertEqual(n1.parent, None)
l1.remove()
self.assertEqual(l1.parent, None)
- def testNodeSetChild(self):
+ def test_node_set_child(self):
l1 = pytree.Leaf(100, "foo")
n1 = pytree.Node(1000, [l1])
# I don't care what it raises, so long as it's an exception
self.assertRaises(Exception, n1.set_child, 0, list)
- def testNodeInsertChild(self):
+ def test_node_insert_child(self):
l1 = pytree.Leaf(100, "foo")
n1 = pytree.Node(1000, [l1])
# I don't care what it raises, so long as it's an exception
self.assertRaises(Exception, n1.insert_child, 0, list)
- def testNodeAppendChild(self):
+ def test_node_append_child(self):
n1 = pytree.Node(1000, [])
l1 = pytree.Leaf(100, "foo")
# I don't care what it raises, so long as it's an exception
self.assertRaises(Exception, n1.append_child, list)
- def testNodeNextSibling(self):
+ def test_node_next_sibling(self):
n1 = pytree.Node(1000, [])
n2 = pytree.Node(1000, [])
p1 = pytree.Node(1000, [n1, n2])
self.assertEqual(n2.next_sibling, None)
self.assertEqual(p1.next_sibling, None)
- def testLeafNextSibling(self):
+ def test_leaf_next_sibling(self):
l1 = pytree.Leaf(100, "a")
l2 = pytree.Leaf(100, "b")
p1 = pytree.Node(1000, [l1, l2])
self.assertEqual(l2.next_sibling, None)
self.assertEqual(p1.next_sibling, None)
- def testNodePrevSibling(self):
+ def test_node_prev_sibling(self):
n1 = pytree.Node(1000, [])
n2 = pytree.Node(1000, [])
p1 = pytree.Node(1000, [n1, n2])
self.assertEqual(n1.prev_sibling, None)
self.assertEqual(p1.prev_sibling, None)
- def testLeafPrevSibling(self):
+ def test_leaf_prev_sibling(self):
l1 = pytree.Leaf(100, "a")
l2 = pytree.Leaf(100, "b")
p1 = pytree.Node(1000, [l1, l2])
"""Unit tests for tree matching patterns."""
- def testBasicPatterns(self):
+ def test_basic_patterns(self):
# Build a tree
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "bar")
self.assertFalse(pn.match(l2, results=r))
self.assertEqual(r, {})
- def testWildcardPatterns(self):
+ def test_wildcard(self):
# Build a tree for testing
l1 = pytree.Leaf(100, "foo")
l2 = pytree.Leaf(100, "bar")
self.assert_(r["pl"] is l3)
r = {}
- def testGenerateMatches(self):
+ def test_generate_matches(self):
la = pytree.Leaf(1, "a")
lb = pytree.Leaf(1, "b")
lc = pytree.Leaf(1, "c")
for c in "abcdef":
self.assertEqual(r["p" + c], pytree.Leaf(1, c))
- def testHasKeyExample(self):
+ def test_has_key_example(self):
pattern = pytree.NodePattern(331,
(pytree.LeafPattern(7),
pytree.WildcardPattern(name="args"),
r = {}
self.assert_(pattern.match(node, r))
self.assertEqual(r["args"], [l2])
-
-
-if __name__ == "__main__":
- import __main__
- support.run_all_tests(__main__)
-#!/usr/bin/env python2.5
""" Test suite for the code in fixes.util """
-# Author: Collin Winter
# Testing imports
from . import support
node = parse('bar()')
fixer_util.touch_import(None, "cgi", node)
self.assertEqual(str(node), 'import cgi\nbar()\n\n')
-
-
-if __name__ == "__main__":
- import __main__
- support.run_all_tests(__main__)
projects / python / commitdiff