def test_args(self) -> None:
# Test that we can insert an argument into a function call normally.
statement = parse_template_expression(
"foo({arg1}, {arg2})", arg1=cst.Name("bar"), arg2=cst.Name("baz"),
)
self.assertEqual(
self.code(statement), "foo(bar, baz)",
)
# Test that we can insert an argument as a special case.
statement = parse_template_expression(
"foo({arg1}, {arg2})",
arg1=cst.Arg(cst.Name("bar")),
arg2=cst.Arg(cst.Name("baz")),
)
self.assertEqual(
self.code(statement), "foo(bar, baz)",
)
def test_simple_expression(self) -> None:
expression = parse_template_expression(
"{a} + {b} + {c}",
a=cst.Name("one"),
b=cst.Name("two"),
c=cst.BinaryOperation(
lpar=(cst.LeftParen(),),
left=cst.Name("three"),
operator=cst.Multiply(),
right=cst.Name("four"),
rpar=(cst.RightParen(),),
),
)
self.assertEqual(
self.code(expression), "one + two + (three * four)",
)
def test_subscript(self) -> None:
# Test that we can insert various subscript slices into an
# acceptible spot.
expression = parse_template_expression(
"Optional[{type}]", type=cst.Name("int"),
)
self.assertEqual(
self.code(expression), "Optional[int]",
)
expression = parse_template_expression(
"Tuple[{type1}, {type2}]", type1=cst.Name("int"), type2=cst.Name("str"),
)
self.assertEqual(
self.code(expression), "Tuple[int, str]",
)
expression = parse_template_expression(
"Optional[{type}]", type=cst.Index(cst.Name("int")),
)
self.assertEqual(
self.code(expression), "Optional[int]",
)
expression = parse_template_expression(
"Optional[{type}]", type=cst.SubscriptElement(cst.Index(cst.Name("int"))),
)
self.assertEqual(
self.code(expression), "Optional[int]",
)
expression = parse_template_expression(
"foo[{slice}]", slice=cst.Slice(cst.Integer("5"), cst.Integer("6")),
)
self.assertEqual(
self.code(expression), "foo[5:6]",
)
expression = parse_template_expression(
"foo[{slice}]",
slice=cst.SubscriptElement(cst.Slice(cst.Integer("5"), cst.Integer("6"))),
)
self.assertEqual(
self.code(expression), "foo[5:6]",
)
expression = parse_template_expression(
"foo[{slice}]", slice=cst.Slice(cst.Integer("5"), cst.Integer("6")),
)
self.assertEqual(
self.code(expression), "foo[5:6]",
)
expression = parse_template_expression(
"foo[{slice}]",
slice=cst.SubscriptElement(cst.Slice(cst.Integer("5"), cst.Integer("6"))),
)
self.assertEqual(
self.code(expression), "foo[5:6]",
)
expression = parse_template_expression(
"foo[{slice1}, {slice2}]",
slice1=cst.Slice(cst.Integer("5"), cst.Integer("6")),
slice2=cst.Index(cst.Integer("7")),
)
self.assertEqual(
self.code(expression), "foo[5:6, 7]",
)
expression = parse_template_expression(
"foo[{slice1}, {slice2}]",
slice1=cst.SubscriptElement(cst.Slice(cst.Integer("5"), cst.Integer("6"))),
slice2=cst.SubscriptElement(cst.Index(cst.Integer("7"))),
)
self.assertEqual(
self.code(expression), "foo[5:6, 7]",
)
expr = body
while isinstance(expr, (cst.BaseSuite, cst.SimpleStatementLine)):
if len(expr.body) == 0:
# fixme: what to do if there is no body
assert 1, "body does not start with block or docstring"
expr = expr.body[0]
if not isinstance(expr, cst.Expr):
# fixme: what to do if there is no initial docstr Expression in the body
assert 1, "there is no Expression in the body"
print(source_tree.code_for_node(expr))
# new_docstr = parse_template_expression("'new docs string'", config=config)
new_docstr = expr.with_changes(
value=parse_template_expression("new \ndoc\nstring", config=config))
print(source_tree.code_for_node(new_docstr))
newtree = ensure_type(source_tree.deep_replace(expr, new_docstr), Module)
print(newtree.code)
print("Done")
# source_tree.code_for_node( body )
# body.deep_replace()
# source_tree.code_for_node( body )
# classdef.ch