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