def replace_decorators(node, capture, filename):
"""
Replaces usage of ``@tornado.<etc>`` with ``@salt.ext.tornado.<etc>``
"""
indent = find_indentation(node)
decorator = _get_decorator(node)
decorator.remove()
decorated = Node(
SYMBOL.decorated,
[
Node(
SYMBOL.decorator,
[
Leaf(TOKEN.AT, "@"),
Name("salt.ext.{}".format(get_decorator_name(decorator))),
Leaf(TOKEN.NEWLINE, "\n"),
],
)
],
prefix=decorator.prefix,
)
node.replace(decorated)
decorated.append_child(node)
if indent is not None:
node.prefix = indent
else:
node.prefix = ""
def _make_bare_import_node(name: str, trailing_nl: bool = False) -> Node:
assert name # non-empty
children = [
Leaf(token.NAME, "import"),
Leaf(token.NAME, name, prefix=" "),
Newline(),
]
if trailing_nl:
children.append(Newline())
return Node(
syms.import_name,
children,
)
def add_future(node, symbol):
root = fixer_util.find_root(node)
for idx, node in enumerate(root.children):
if (node.type == syms.simple_stmt and len(node.children) > 0
and node.children[0].type == token.STRING):
# skip over docstring
continue
names = _check_future_import(node)
if not names:
# not a future statement; need to insert before this
break
if symbol in names:
# already imported
return
import_ = fixer_util.FromImport("__future__",
[Leaf(token.NAME, symbol, prefix=" ")])
# Place after any comments or whitespace. (copyright, shebang etc.)
import_.prefix = node.prefix
node.prefix = ""
children = [import_, fixer_util.Newline()]
root.insert_child(idx, Node(syms.simple_stmt, children))
def _add_arg_name(argument_node):
nonlocal encounter_kwarg
nonlocal idx
if args_list is None:
return
if encounter_kwarg:
return
if idx >= len(args_list):
msg = 'args_list: "{}" is shorter than positional arguments.'.format(
args_list)
log_error(filename, argument_node.get_lineno(), msg)
return
if len(argument_node.children) >= 3:
encounter_kwarg = True
msg = 'args_list: "{}" is longer than positional arguments, redundant arguments will be skipped.'.format(
args_list)
log_info(filename, argument_node.get_lineno(), msg)
return
key = args_list[idx]
argument_node.insert_child(0, Leaf(token.EQUAL, "="))
argument_node.insert_child(0, Name(key))
argument_node.children[0].prefix = argument_node.children[2].prefix
argument_node.children[2].prefix = ""
idx += 1
msg = 'add argument name "{}" for {}-th argument.'.format(key, idx)
log_debug(filename, argument_node.get_lineno(), msg)
def _make_from_import_node(left: str,
right: Sequence[str],
trailing_nl: bool = False) -> Node:
assert right # non-empty
name_leaves = [Leaf(token.NAME, right[0], prefix=" ")]
name_leaves.extend(
Leaf(token.NAME, name, prefix=", ") for name in right[1:])
children = [
Leaf(token.NAME, "from"),
Leaf(token.NAME, left, prefix=" "),
Leaf(token.NAME, "import", prefix=" "),
Node(syms.import_as_names, name_leaves),
Newline(),
]
if trailing_nl:
children.append(Newline())
return Node(syms.import_from, children)
def test(self):
kids = [
None,
[Leaf(token.NUMBER, 1), Leaf(token.NUMBER, 2), Leaf(token.NUMBER, 3)],
[
Leaf(token.NUMBER, 1),
Leaf(token.NUMBER, 3),
Leaf(token.NUMBER, 2),
Leaf(token.NUMBER, 4),
],
[Leaf(token.STRING, "b"), Leaf(token.STRING, "j", prefix=" ")],
]
self.assertStr(self._Call("A"), "A()")
self.assertStr(self._Call("b", kids[1]), "b(1,2,3)")
self.assertStr(self._Call("a.b().c", kids[2]), "a.b().c(1,3,2,4)")
self.assertStr(self._Call("d", kids[3], prefix=" "), " d(b, j)")
def add_marker(node, capture, filename):
"""Add ``MARKER`` to the functions."""
indent = _get_indent(node)
decorated = Node(
SYMBOL.decorated,
[
Node(
SYMBOL.decorator,
[Leaf(TOKEN.AT, "@"),
Name(MARKER),
Leaf(TOKEN.NEWLINE, "\n")],
)
],
prefix=node.prefix,
)
node.replace(decorated)
decorated.append_child(node)
if indent is not None:
node.prefix = indent
else:
node.prefix = ""
def encapsulate_transform(
node: LN, capture: Capture, filename: Filename
) -> None:
if "attr_assignment" in capture:
leaf = capture["attr_name"]
leaf.replace(Name(new_name, prefix=leaf.prefix))
if make_property:
# TODO: capture and use type annotation from original assignment
class_node = get_class(node)
suite = find_first(class_node, SYMBOL.suite)
assert isinstance(suite, Node)
indent_node = find_first(suite, TOKEN.INDENT)
assert isinstance(indent_node, Leaf)
indent = indent_node.value
getter = Node(
SYMBOL.decorated,
[
Node(
SYMBOL.decorator,
[
Leaf(TOKEN.AT, "@"),
Name("property"),
Leaf(TOKEN.NEWLINE, "\n"),
],
),
Node(
SYMBOL.funcdef,
[
Name("def", indent),
Name(old_name, prefix=" "),
Node(
SYMBOL.parameters,
[LParen(), Name("self"), RParen()],
),
Leaf(TOKEN.COLON, ":"),
Node(
SYMBOL.suite,
[
Newline(),
Leaf(TOKEN.INDENT, indent.value + " "),
Node(
SYMBOL.simple_stmt,
[
Node(
SYMBOL.return_stmt,
[
Name("return"),
Node(
SYMBOL.power,
Attr(
Name("self"),
Name(new_name),
),
prefix=" ",
),
],
),
Newline(),
],
),
Leaf(TOKEN.DEDENT, "\n" + indent),
],
),
],
prefix=indent,
),
],
)
setter = Node(
SYMBOL.decorated,
[
Node(
SYMBOL.decorator,
[
Leaf(TOKEN.AT, "@"),
Node(
SYMBOL.dotted_name,
[Name(old_name), Dot(), Name("setter")],
),
Leaf(TOKEN.NEWLINE, "\n"),
],
),
Node(
SYMBOL.funcdef,
[
Name("def", indent),
Name(old_name, prefix=" "),
Node(
SYMBOL.parameters,
[
LParen(),
Node(
SYMBOL.typedargslist,
[
Name("self"),
Comma(),
Name("value", prefix=" "),
],
),
RParen(),
],
),
Leaf(TOKEN.COLON, ":"),
Node(
SYMBOL.suite,
[
Newline(),
Leaf(TOKEN.INDENT, indent + " "),
Node(
SYMBOL.simple_stmt,
[
Node(
SYMBOL.expr_stmt,
[
Node(
SYMBOL.power,
Attr(
Name("self"),
Name(new_name),
),
),
Leaf(
TOKEN.EQUAL,
"=",
prefix=" ",
),
Name("value", prefix=" "),
],
),
Newline(),
],
),
Leaf(TOKEN.DEDENT, "\n" + indent),
],
),
],
prefix=indent,
),
],
)
suite.insert_child(-1, getter)
suite.insert_child(-1, setter)
prev = find_previous(getter, TOKEN.DEDENT, recursive=True)
curr = find_last(setter, TOKEN.DEDENT, recursive=True)
assert isinstance(prev, Leaf) and isinstance(curr, Leaf)
prev.prefix, curr.prefix = curr.prefix, prev.prefix
prev.value, curr.value = curr.value, prev.value
def keyword(name, **kwargs):
"""
A helper to produce keyword nodes
"""
kwargs.setdefault("prefix", " ")
return Leaf(TOKEN.NAME, name, **kwargs)
def Plus():
return Leaf(token.PLUS, "+")
def RBrace():
return Leaf(token.RBRACE, "]")
def LBrace():
return Leaf(token.LBRACE, "[")
def makeLeaf( type_name, value, prefix="" ):
type_num = typeNameToNum( type_name )
return Leaf( type_num, value, prefix=prefix )
