From b4f903e0f31befbbf267cec23e3b4548015146da Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 17 Sep 2021 22:14:25 +0200 Subject: [PATCH 1/5] added comprhensions to detecting vars --- rope/refactor/extract.py | 25 +++++++ ropetest/refactor/extracttest.py | 120 +++++++++++++++++++++++++++++++ 2 files changed, 145 insertions(+) diff --git a/rope/refactor/extract.py b/rope/refactor/extract.py index dfab070dc..7c1b7a737 100644 --- a/rope/refactor/extract.py +++ b/rope/refactor/extract.py @@ -690,6 +690,31 @@ def _AugAssign(self, node): def _ClassDef(self, node): self._written_variable(node.name, node.lineno) + def _ListComp(self, node): + self._comp_exp(node) + + def _GeneratorExp(self, node): + self._comp_exp(node) + + def _SetComp(self, node): + self._comp_exp(node) + + def _DictComp(self, node): + self._comp_exp(node) + + def _comp_exp(self, node): + read = OrderedSet(self.read) + written = OrderedSet(self.written) + maybe_written = OrderedSet(self.maybe_written) + + for child in ast.get_child_nodes(node): + ast.walk(child, self) + + comp_names = set([name.target.id for name in node.generators]) + self.read = self.read - comp_names | read + self.written = self.written - comp_names | written + self.maybe_written = self.maybe_written - comp_names | maybe_written + def _handle_conditional_node(self, node): self.conditional = True try: diff --git a/ropetest/refactor/extracttest.py b/ropetest/refactor/extracttest.py index f1670dfcc..81f4da90c 100644 --- a/ropetest/refactor/extracttest.py +++ b/ropetest/refactor/extracttest.py @@ -1349,6 +1349,126 @@ def new_func(): ''') self.assertEqual(expected, refactored) + def test_extract_with_list_compehention(self): + code = dedent('''\ + def f(): + y = [1,2,3,4] + a = sum([x for x in y]) + b = sum([x for x in y]) + + print(a, b) + + f() + ''') + extract_target = ' a = sum([x for x in y])\n' + start, end = code.index(extract_target), code.index(extract_target) + len(extract_target) + refactored = self.do_extract_method(code, start, end, '_a') + expected = dedent('''\ + def f(): + y = [1,2,3,4] + a = _a(y) + b = sum([x for x in y]) + + print(a, b) + + def _a(y): + a = sum([x for x in y]) + return a + + f() + ''') + self.assertEqual(expected, refactored) + + def test_extract_with_generator(self): + code = dedent('''\ + def f(): + y = [1,2,3,4] + a = sum(x for x in y) + b = sum(x for x in y) + + print(a, b) + + f() + ''') + extract_target = ' a = sum(x for x in y)\n' + start, end = code.index(extract_target), code.index(extract_target) + len(extract_target) + refactored = self.do_extract_method(code, start, end, '_a') + expected = dedent('''\ + def f(): + y = [1,2,3,4] + a = _a(y) + b = sum(x for x in y) + + print(a, b) + + def _a(y): + a = sum(x for x in y) + return a + + f() + ''') + self.assertEqual(expected, refactored) + + def test_extract_with_set_compehention(self): + code = dedent('''\ + def f(): + y = [1,2,3,4] + a = sum({x for x in y}) + b = sum({x for x in y}) + + print(a, b) + + f() + ''') + extract_target = ' a = sum({x for x in y})\n' + start, end = code.index(extract_target), code.index(extract_target) + len(extract_target) + refactored = self.do_extract_method(code, start, end, '_a') + expected = dedent('''\ + def f(): + y = [1,2,3,4] + a = _a(y) + b = sum({x for x in y}) + + print(a, b) + + def _a(y): + a = sum({x for x in y}) + return a + + f() + ''') + self.assertEqual(expected, refactored) + + def test_extract_with_dict_compehention(self): + code = dedent('''\ + def f(): + y = [1,2,3,4] + a = sum({x: x for x in y}) + b = sum({x: x for x in y}) + + print(a, b) + + f() + ''') + extract_target = ' a = sum({x: x for x in y})\n' + start, end = code.index(extract_target), code.index(extract_target) + len(extract_target) + refactored = self.do_extract_method(code, start, end, '_a') + expected = dedent('''\ + def f(): + y = [1,2,3,4] + a = _a(y) + b = sum({x: x for x in y}) + + print(a, b) + + def _a(y): + a = sum({x: x for x in y}) + return a + + f() + ''') + self.assertEqual(expected, refactored) + if __name__ == '__main__': unittest.main() From 064f2ef1246dd5a8f2328b054bb3d940697866a6 Mon Sep 17 00:00:00 2001 From: Lie Ryan Date: Sun, 26 Sep 2021 18:07:38 +1000 Subject: [PATCH 2/5] Revert dedent() styling --- ropetest/refactor/extracttest.py | 606 +++++++++++-------------------- 1 file changed, 202 insertions(+), 404 deletions(-) diff --git a/ropetest/refactor/extracttest.py b/ropetest/refactor/extracttest.py index 364171512..1d3c2ed83 100644 --- a/ropetest/refactor/extracttest.py +++ b/ropetest/refactor/extracttest.py @@ -41,48 +41,40 @@ def _convert_line_range_to_offset(self, code, start, end): return lines.get_line_start(start), lines.get_line_end(end) def test_simple_extract_function(self): - code = dedent( - """\ + code = dedent("""\ def a_func(): print('one') print('two') - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 2, 2) refactored = self.do_extract_method(code, start, end, "extracted") - expected = dedent( - """\ + expected = dedent("""\ def a_func(): extracted() print('two') def extracted(): print('one') - """ - ) + """) self.assertEqual(expected, refactored) def test_simple_extract_function_one_line(self): - code = dedent( - """\ + code = dedent("""\ def a_func(): resp = 'one' print(resp) - """ - ) + """) selected = "'one'" start, end = code.index(selected), code.index(selected) + len(selected) refactored = self.do_extract_method(code, start, end, "extracted") - expected = dedent( - """\ + expected = dedent("""\ def a_func(): resp = extracted() print(resp) def extracted(): return 'one' - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_function_at_the_end_of_file(self): @@ -106,26 +98,22 @@ def test_extract_function_after_scope(self): @testutils.only_for("3.5") def test_extract_function_containing_dict_generalized_unpacking(self): - code = dedent( - """\ + code = dedent("""\ def a_func(dict1): dict2 = {} a_var = {a: b, **dict1, **dict2} - """ - ) + """) start = code.index("{a") end = code.index("2}") + len("2}") refactored = self.do_extract_method(code, start, end, "extracted") - expected = dedent( - """\ + expected = dedent("""\ def a_func(dict1): dict2 = {} a_var = extracted(dict1, dict2) def extracted(dict1, dict2): return {a: b, **dict1, **dict2} - """ - ) + """) self.assertEqual(expected, refactored) def test_simple_extract_function_with_parameter(self): @@ -499,19 +487,16 @@ def test_breaks_and_continues_outside_loops(self): self.do_extract_method(code, start, end, "new_func") def test_for_loop_variable_scope(self): - code = dedent( - """\ + code = dedent("""\ def my_func(): i = 0 for dummy in range(10): i += 1 print(i) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 4, 5) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def my_func(): i = 0 for dummy in range(10): @@ -521,24 +506,20 @@ def new_func(i): i += 1 print(i) return i - """ - ) + """) self.assertEqual(expected, refactored) def test_for_loop_variable_scope_read_then_write(self): - code = dedent( - """\ + code = dedent("""\ def my_func(): i = 0 for dummy in range(10): a = i + 1 i = a + 1 - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 4, 5) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def my_func(): i = 0 for dummy in range(10): @@ -548,24 +529,20 @@ def new_func(i): a = i + 1 i = a + 1 return i - """ - ) + """) self.assertEqual(expected, refactored) def test_for_loop_variable_scope_write_then_read(self): - code = dedent( - """\ + code = dedent("""\ def my_func(): i = 0 for dummy in range(10): i = 'hello' print(i) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 4, 5) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def my_func(): i = 0 for dummy in range(10): @@ -574,24 +551,20 @@ def my_func(): def new_func(): i = 'hello' print(i) - """ - ) + """) self.assertEqual(expected, refactored) def test_for_loop_variable_scope_write_only(self): - code = dedent( - """\ + code = dedent("""\ def my_func(): i = 0 for num in range(10): i = 'hello' + num print(i) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 4, 4) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def my_func(): i = 0 for num in range(10): @@ -601,8 +574,7 @@ def my_func(): def new_func(num): i = 'hello' + num return i - """ - ) + """) self.assertEqual(expected, refactored) def test_variable_writes_followed_by_variable_reads_after_extraction(self): @@ -637,20 +609,16 @@ def test_extract_variable(self): @testutils.only_for_versions_higher("3.6") def test_extract_variable_f_string(self): - code = dedent( - """\ + code = dedent("""\ foo(f"abc {a_var} def", 10) - """ - ) + """) start = code.index('f"') end = code.index('def"') + 4 refactored = self.do_extract_variable(code, start, end, "new_var") - expected = dedent( - """\ + expected = dedent("""\ new_var = f"abc {a_var} def" foo(new_var, 10) - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_variable_multiple_lines(self): @@ -794,42 +762,35 @@ def test_extract_method_and_extra_blank_lines(self): @testutils.only_for_versions_higher("3.6") def test_extract_method_f_string_extract_method(self): - code = dedent( - """\ + code = dedent("""\ def func(a_var): foo(f"abc {a_var}", 10) - """ - ) + """) start = code.index('f"') end = code.index('}"') + 2 refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def func(a_var): foo(new_func(a_var), 10) def new_func(a_var): return f"abc {a_var}" - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.6") def test_extract_method_f_string_extract_method_complex_expression(self): - code = dedent( - """\ + code = dedent("""\ def func(a_var): b_var = int c_var = 10 fill = 10 foo(f"abc {a_var + f'{b_var(a_var)}':{fill}16}" f"{c_var}", 10) - """ - ) + """) start = code.index('f"') end = code.index('c_var}"') + 7 refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def func(a_var): b_var = int c_var = 10 @@ -838,55 +799,46 @@ def func(a_var): def new_func(a_var, b_var, c_var, fill): return f"abc {a_var + f'{b_var(a_var)}':{fill}16}" f"{c_var}" - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.6") def test_extract_method_f_string_false_comment(self): - code = dedent( - """\ + code = dedent("""\ def func(a_var): foo(f"abc {a_var} # ", 10) - """ - ) + """) start = code.index('f"') end = code.index('# "') + 3 refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def func(a_var): foo(new_func(a_var), 10) def new_func(a_var): return f"abc {a_var} # " - """ - ) + """) self.assertEqual(expected, refactored) @unittest.expectedFailure @testutils.only_for_versions_higher("3.6") def test_extract_method_f_string_false_format_value_in_regular_string(self): - code = dedent( - """\ + code = dedent("""\ def func(a_var): b_var = 1 foo(f"abc {a_var} " "{b_var}" f"{b_var} def", 10) - """ - ) + """) start = code.index('f"') end = code.index('def"') + 4 refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def func(a_var): b_var = 1 foo(new_func(a_var, b_var), 10) def new_func(a_var, b_var): return f"abc {a_var} " "{b_var}" f"{b_var} def" - """ - ) + """) self.assertEqual(expected, refactored) def test_variable_writes_in_the_same_line_as_variable_read(self): @@ -898,39 +850,32 @@ def test_variable_writes_in_the_same_line_as_variable_read(self): self.assertEqual(expected, refactored) def test_variable_writes_in_the_same_line_as_variable_read2(self): - code = dedent( - """\ + code = dedent("""\ a = 1 a += 1 - """ - ) + """) start = code.index("\n") + 1 end = len(code) refactored = self.do_extract_method(code, start, end, "new_f", global_=True) - expected = dedent( - """\ + expected = dedent("""\ a = 1 def new_f(a): a += 1 new_f(a) - """ - ) + """) self.assertEqual(expected, refactored) def test_variable_writes_in_the_same_line_as_variable_read3(self): - code = dedent( - """\ + code = dedent("""\ a = 1 a += 1 print(a) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 2, 2) refactored = self.do_extract_method(code, start, end, "new_f") - expected = dedent( - """\ + expected = dedent("""\ a = 1 def new_f(a): @@ -939,21 +884,17 @@ def new_f(a): a = new_f(a) print(a) - """ - ) + """) self.assertEqual(expected, refactored) def test_variable_writes_only(self): - code = dedent( - """\ + code = dedent("""\ i = 1 print(i) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 1, 1) refactored = self.do_extract_method(code, start, end, "new_f") - expected = dedent( - """\ + expected = dedent("""\ def new_f(): i = 1 @@ -961,8 +902,7 @@ def new_f(): i = new_f() print(i) - """ - ) + """) self.assertEqual(expected, refactored) def test_variable_and_similar_expressions(self): @@ -1325,18 +1265,15 @@ def test_passing_conditional_updated_vars_in_extracted(self): self.assertEqual(expected, refactored) def test_returning_conditional_updated_vars_in_extracted(self): - code = dedent( - """\ + code = dedent("""\ def f(a): if 0: a = 1 print(a) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 2, 3) refactored = self.do_extract_method(code, start, end, "g") - expected = dedent( - """\ + expected = dedent("""\ def f(a): a = g(a) print(a) @@ -1345,8 +1282,7 @@ def g(a): if 0: a = 1 return a - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_method_with_variables_possibly_written_to(self): @@ -1391,8 +1327,7 @@ def test_extract_method_with_list_comprehension(self): self.assertEqual(expected, refactored) def test_extract_method_with_list_comprehension_and_iter(self): - code = dedent( - """\ + code = dedent("""\ def foo(): x = [e for e in []] f = 23 @@ -1400,12 +1335,10 @@ def foo(): for x, f in x: def bar(): x[42] = 1 - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 4, 7) refactored = self.do_extract_method(code, start, end, "baz") - expected = dedent( - """\ + expected = dedent("""\ def foo(): x = [e for e in []] f = 23 @@ -1416,8 +1349,7 @@ def baz(x): for x, f in x: def bar(): x[42] = 1 - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_method_with_list_comprehension_and_orelse(self): @@ -1494,33 +1426,28 @@ def test_extract_function_with_for_else_statemant_more(self): self.assertEqual(expected, refactored) def test_extract_function_with_for_else_statemant_outside_loops(self): - code = dedent( - """\ + code = dedent("""\ def a_func(): for i in range(10): a = i else: a=None - """ - ) + """) start = code.index("a = i") end = len(code) - 1 with self.assertRaises(rope.base.exceptions.RefactoringError): self.do_extract_method(code, start, end, "new_func") def test_extract_function_with_inline_assignment_in_method(self): - code = dedent( - """\ + code = dedent("""\ def foo(): i = 1 i += 1 print(i) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 3, 3) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def foo(): i = 1 i = new_func(i) @@ -1529,24 +1456,20 @@ def foo(): def new_func(i): i += 1 return i - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.8") def test_extract_function_statement_with_inline_assignment_in_condition(self): - code = dedent( - """\ + code = dedent("""\ def foo(a): if i := a == 5: i += 1 print(i) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 2, 3) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def foo(a): i = new_func(a) print(i) @@ -1555,27 +1478,23 @@ def new_func(a): if i := a == 5: i += 1 return i - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.8") def test_extract_function_expression_with_inline_assignment_in_condition(self): - code = dedent( - """\ + code = dedent("""\ def foo(a): if i := a == 5: i += 1 print(i) - """ - ) + """) extract_target = "i := a == 5" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def foo(a): if i := new_func(a): i += 1 @@ -1583,28 +1502,24 @@ def foo(a): def new_func(a): return (i := a == 5) - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.8") def test_extract_function_expression_with_inline_assignment_complex(self): - code = dedent( - """\ + code = dedent("""\ def foo(a): if i := a == (c := 5): i += 1 c += 1 print(i) - """ - ) + """) extract_target = "i := a == (c := 5)" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def foo(a): if i, c := new_func(a): i += 1 @@ -1613,22 +1528,19 @@ def foo(a): def new_func(a): return (i := a == (c := 5)) - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.8") def test_extract_function_expression_with_inline_assignment_in_inner_expression( self, ): - code = dedent( - """\ + code = dedent("""\ def foo(a): if a == (c := 5): c += 1 print(i) - """ - ) + """) extract_target = "a == (c := 5)" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target @@ -1640,58 +1552,47 @@ def foo(a): self.do_extract_method(code, start, end, "new_func") def test_extract_exec(self): - code = dedent( - """\ + code = dedent("""\ exec("def f(): pass", {}) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 1, 1) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def new_func(): exec("def f(): pass", {}) new_func() - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_lower("3") def test_extract_exec_statement(self): - code = dedent( - """\ + code = dedent("""\ exec "def f(): pass" in {} - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 1, 1) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def new_func(): exec "def f(): pass" in {} new_func() - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.5") def test_extract_async_function(self): - code = dedent( - """\ + code = dedent("""\ async def my_func(my_list): for x in my_list: var = x + 1 return var - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 3, 3) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ async def my_func(my_list): for x in my_list: var = new_func(x) @@ -1700,25 +1601,21 @@ async def my_func(my_list): def new_func(x): var = x + 1 return var - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.5") def test_extract_inner_async_function(self): - code = dedent( - """\ + code = dedent("""\ def my_func(my_list): async def inner_func(my_list): for x in my_list: var = x + 1 return inner_func - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 2, 4) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def my_func(my_list): inner_func = new_func(my_list) return inner_func @@ -1728,25 +1625,21 @@ async def inner_func(my_list): for x in my_list: var = x + 1 return inner_func - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.5") def test_extract_around_inner_async_function(self): - code = dedent( - """\ + code = dedent("""\ def my_func(lst): async def inner_func(obj): for x in obj: var = x + 1 return map(inner_func, lst) - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 5, 5) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ def my_func(lst): async def inner_func(obj): for x in obj: @@ -1755,24 +1648,20 @@ async def inner_func(obj): def new_func(inner_func, lst): return map(inner_func, lst) - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.5") def test_extract_refactor_around_async_for_loop(self): - code = dedent( - """\ + code = dedent("""\ async def my_func(my_list): async for x in my_list: var = x + 1 return var - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 3, 3) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ async def my_func(my_list): async for x in my_list: var = new_func(x) @@ -1781,8 +1670,7 @@ async def my_func(my_list): def new_func(x): var = x + 1 return var - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.5") @@ -1793,14 +1681,12 @@ def test_extract_refactor_containing_async_for_loop_should_error_before_py38(sel higher because support for ast.PyCF_ALLOW_TOP_LEVEL_AWAIT was only added to the standard library in Python 3.8. """ - code = dedent( - """\ + code = dedent("""\ async def my_func(my_list): async for x in my_list: var = x + 1 return var - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 2, 3) with self.assertRaisesRegexp( rope.base.exceptions.RefactoringError, @@ -1810,18 +1696,15 @@ async def my_func(my_list): @testutils.only_for_versions_higher("3.8") def test_extract_refactor_containing_async_for_loop_is_supported_after_py38(self): - code = dedent( - """\ + code = dedent("""\ async def my_func(my_list): async for x in my_list: var = x + 1 return var - """ - ) + """) start, end = self._convert_line_range_to_offset(code, 2, 3) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ async def my_func(my_list): var = new_func(my_list) return var @@ -1830,25 +1713,21 @@ def new_func(my_list): async for x in my_list: var = x + 1 return var - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.5") def test_extract_await_expression(self): - code = dedent( - """\ + code = dedent("""\ async def my_func(my_list): for url in my_list: resp = await request(url) return resp - """ - ) + """) selected = "request(url)" start, end = code.index(selected), code.index(selected) + len(selected) refactored = self.do_extract_method(code, start, end, "new_func") - expected = dedent( - """\ + expected = dedent("""\ async def my_func(my_list): for url in my_list: resp = await new_func(url) @@ -1856,19 +1735,16 @@ async def my_func(my_list): def new_func(url): return request(url) - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_to_staticmethod(self): - code = dedent( - """\ + code = dedent("""\ class A: def first_method(self): a_var = 1 b_var = a_var + 1 - """ - ) + """) extract_target = "a_var + 1" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target @@ -1876,8 +1752,7 @@ def first_method(self): refactored = self.do_extract_method( code, start, end, "second_method", kind="staticmethod" ) - expected = dedent( - """\ + expected = dedent("""\ class A: def first_method(self): a_var = 1 @@ -1886,19 +1761,16 @@ def first_method(self): @staticmethod def second_method(a_var): return a_var + 1 - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_to_staticmethod_when_self_in_body(self): - code = dedent( - """\ + code = dedent("""\ class A: def first_method(self): a_var = 1 b_var = self.a_var + 1 - """ - ) + """) extract_target = "self.a_var + 1" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target @@ -1906,8 +1778,7 @@ def first_method(self): refactored = self.do_extract_method( code, start, end, "second_method", kind="staticmethod" ) - expected = dedent( - """\ + expected = dedent("""\ class A: def first_method(self): a_var = 1 @@ -1916,18 +1787,15 @@ def first_method(self): @staticmethod def second_method(self): return self.a_var + 1 - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_from_function_to_staticmethod_raises_exception(self): - code = dedent( - """\ + code = dedent("""\ def first_method(): a_var = 1 b_var = a_var + 1 - """ - ) + """) extract_target = "a_var + 1" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target @@ -1941,18 +1809,15 @@ def first_method(): ) def test_extract_method_in_classmethods(self): - code = dedent( - """\ + code = dedent("""\ class AClass(object): @classmethod def func2(cls): b = 1 - """ - ) + """) start = code.index(" 1") + 1 refactored = self.do_extract_method(code, start, start + 1, "one", similar=True) - expected = dedent( - """\ + expected = dedent("""\ class AClass(object): @classmethod def func2(cls): @@ -1961,18 +1826,15 @@ def func2(cls): @classmethod def one(cls): return 1 - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_from_function_to_classmethod_raises_exception(self): - code = dedent( - """\ + code = dedent("""\ def first_method(): a_var = 1 b_var = a_var + 1 - """ - ) + """) extract_target = "a_var + 1" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target @@ -1986,14 +1848,12 @@ def first_method(): ) def test_extract_to_classmethod_when_self_in_body(self): - code = dedent( - """\ + code = dedent("""\ class A: def first_method(self): a_var = 1 b_var = self.a_var + 1 - """ - ) + """) extract_target = "self.a_var + 1" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target @@ -2001,8 +1861,7 @@ def first_method(self): refactored = self.do_extract_method( code, start, end, "second_method", kind="classmethod" ) - expected = dedent( - """\ + expected = dedent("""\ class A: def first_method(self): a_var = 1 @@ -2011,19 +1870,16 @@ def first_method(self): @classmethod def second_method(cls, self): return self.a_var + 1 - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_to_classmethod(self): - code = dedent( - """\ + code = dedent("""\ class A: def first_method(self): a_var = 1 b_var = a_var + 1 - """ - ) + """) extract_target = "a_var + 1" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target @@ -2031,8 +1887,7 @@ def first_method(self): refactored = self.do_extract_method( code, start, end, "second_method", kind="classmethod" ) - expected = dedent( - """\ + expected = dedent("""\ class A: def first_method(self): a_var = 1 @@ -2041,26 +1896,22 @@ def first_method(self): @classmethod def second_method(cls, a_var): return a_var + 1 - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_to_classmethod_when_name_starts_with_at_sign(self): - code = dedent( - """\ + code = dedent("""\ class A: def first_method(self): a_var = 1 b_var = a_var + 1 - """ - ) + """) extract_target = "a_var + 1" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "@second_method") - expected = dedent( - """\ + expected = dedent("""\ class A: def first_method(self): a_var = 1 @@ -2069,26 +1920,22 @@ def first_method(self): @classmethod def second_method(cls, a_var): return a_var + 1 - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_to_staticmethod_when_name_starts_with_dollar_sign(self): - code = dedent( - """\ + code = dedent("""\ class A: def first_method(self): a_var = 1 b_var = a_var + 1 - """ - ) + """) extract_target = "a_var + 1" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "$second_method") - expected = dedent( - """\ + expected = dedent("""\ class A: def first_method(self): a_var = 1 @@ -2097,8 +1944,7 @@ def first_method(self): @staticmethod def second_method(a_var): return a_var + 1 - """ - ) + """) self.assertEqual(expected, refactored) def test_raises_exception_when_sign_in_name_and_kind_mismatch(self): @@ -2108,22 +1954,19 @@ def test_raises_exception_when_sign_in_name_and_kind_mismatch(self): self.do_extract_method("code", 0, 1, "$second_method", kind="classmethod") def test_extracting_from_static_with_function_arg(self): - code = dedent( - """\ + code = dedent("""\ class A: @staticmethod def first_method(someargs): b_var = someargs + 1 - """ - ) + """) extract_target = "someargs + 1" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "second_method") - expected = dedent( - """\ + expected = dedent("""\ class A: @staticmethod def first_method(someargs): @@ -2132,14 +1975,12 @@ def first_method(someargs): @staticmethod def second_method(someargs): return someargs + 1 - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_with_list_compehention(self): - code = dedent( - """\ + code = dedent("""\ def f(): y = [1,2,3,4] a = sum([x for x in y]) @@ -2148,15 +1989,13 @@ def f(): print(a, b) f() - """ - ) + """) extract_target = " a = sum([x for x in y])\n" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "_a") - expected = dedent( - """\ + expected = dedent("""\ def f(): y = [1,2,3,4] a = _a(y) @@ -2169,13 +2008,11 @@ def _a(y): return a f() - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_with_generator(self): - code = dedent( - """\ + code = dedent("""\ def f(): y = [1,2,3,4] a = sum(x for x in y) @@ -2184,15 +2021,13 @@ def f(): print(a, b) f() - """ - ) + """) extract_target = " a = sum(x for x in y)\n" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "_a") - expected = dedent( - """\ + expected = dedent("""\ def f(): y = [1,2,3,4] a = _a(y) @@ -2205,13 +2040,11 @@ def _a(y): return a f() - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_with_set_compehention(self): - code = dedent( - """\ + code = dedent("""\ def f(): y = [1,2,3,4] a = sum({x for x in y}) @@ -2220,15 +2053,13 @@ def f(): print(a, b) f() - """ - ) + """) extract_target = " a = sum({x for x in y})\n" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "_a") - expected = dedent( - """\ + expected = dedent("""\ def f(): y = [1,2,3,4] a = _a(y) @@ -2241,13 +2072,11 @@ def _a(y): return a f() - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_with_dict_compehention(self): - code = dedent( - """\ + code = dedent("""\ def f(): y = [1,2,3,4] a = sum({x: x for x in y}) @@ -2256,15 +2085,13 @@ def f(): print(a, b) f() - """ - ) + """) extract_target = " a = sum({x: x for x in y})\n" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "_a") - expected = dedent( - """\ + expected = dedent("""\ def f(): y = [1,2,3,4] a = _a(y) @@ -2277,27 +2104,23 @@ def _a(y): return a f() - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_function_expression_with_assignment_to_attribute(self): - code = dedent( - """\ + code = dedent("""\ class A(object): def func(self): self.var_a = 1 var_bb = self.var_a - """ - ) + """) extract_target = "= self.var_a" start, end = ( code.index(extract_target) + 2, code.index(extract_target) + 2 + len(extract_target) - 2, ) refactored = self.do_extract_method(code, start, end, "new_func", similar=True) - expected = dedent( - """\ + expected = dedent("""\ class A(object): def func(self): self.var_a = 1 @@ -2305,28 +2128,24 @@ def func(self): def new_func(self): return self.var_a - """ - ) + """) self.assertEqual(expected, refactored) def test_extract_function_expression_with_assignment_index(self): - code = dedent( - """\ + code = dedent("""\ class A(object): def func(self, val): self[val] = 1 var_bb = self[val] - """ - ) + """) extract_target = "= self[val]" start, end = ( code.index(extract_target) + 2, code.index(extract_target) + 2 + len(extract_target) - 2, ) refactored = self.do_extract_method(code, start, end, "new_func", similar=True) - expected = dedent( - """\ + expected = dedent("""\ class A(object): def func(self, val): self[val] = 1 @@ -2334,14 +2153,12 @@ def func(self, val): def new_func(self, val): return self[val] - """ - ) + """) self.assertEqual(expected, refactored) def test_extraction_method_with_global_variable(self): - code = dedent( - """\ + code = dedent("""\ g = None def f(): @@ -2351,15 +2168,13 @@ def f(): f() print(g) - """ - ) + """) extract_target = "g = 2" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "_g") - expected = dedent( - """\ + expected = dedent("""\ g = None def f(): @@ -2373,13 +2188,11 @@ def _g(): f() print(g) - """ - ) + """) self.assertEqual(expected, refactored) def test_extraction_method_with_global_variable_and_global_declaration(self): - code = dedent( - """\ + code = dedent("""\ g = None def f(): @@ -2389,12 +2202,10 @@ def f(): f() print(g) - """ - ) + """) start, end = 23, 42 refactored = self.do_extract_method(code, start, end, "_g") - expected = dedent( - """\ + expected = dedent("""\ g = None def f(): @@ -2407,13 +2218,11 @@ def _g(): f() print(g) - """ - ) + """) self.assertEqual(expected, refactored) def test_extraction_one_line_with_global_variable_read_only(self): - code = dedent( - """\ + code = dedent("""\ g = None def f(): @@ -2423,13 +2232,11 @@ def f(): f() print(g) - """ - ) + """) extract_target = "= g" start, end = code.index(extract_target) + 2, code.index(extract_target) + 3 refactored = self.do_extract_method(code, start, end, "_g") - expected = dedent( - """\ + expected = dedent("""\ g = None def f(): @@ -2442,14 +2249,12 @@ def _g(): f() print(g) - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.8") def test_extraction_one_line_with_global_variable(self): - code = dedent( - """\ + code = dedent("""\ g = None def f(): @@ -2460,15 +2265,13 @@ def f(): f() print(g) - """ - ) + """) extract_target = "g := 4" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "_g") - expected = dedent( - """\ + expected = dedent("""\ g = None def f(): @@ -2483,14 +2286,12 @@ def _g(): f() print(g) - """ - ) + """) self.assertEqual(expected, refactored) @testutils.only_for_versions_higher("3.8") def test_extraction_one_line_with_global_variable_has_postread(self): - code = dedent( - """\ + code = dedent("""\ g = None def f(): @@ -2501,15 +2302,13 @@ def f(): f() print(g) - """ - ) + """) extract_target = "g := 4" start, end = code.index(extract_target), code.index(extract_target) + len( extract_target ) refactored = self.do_extract_method(code, start, end, "_g") - expected = dedent( - """\ + expected = dedent("""\ g = None def f(): @@ -2524,6 +2323,5 @@ def _g(): f() print(g) - """ - ) + """) self.assertEqual(expected, refactored) From 03dae8fca1d920cd29e9f3734c3aa35811217476 Mon Sep 17 00:00:00 2001 From: Lie Ryan Date: Sun, 26 Sep 2021 18:09:02 +1000 Subject: [PATCH 3/5] Fix black to force-exclude ropetest --- pyproject.toml | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index b6407a20b..8533c1aef 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,4 +1,5 @@ [tool.black] target-version = ['py27', 'py33', 'py34', 'py35', 'py36', 'py37', 'py38', 'py39'] -exclude = 'ropetest' +include = 'rope/.*\.pyi?$' +force-exclude = 'ropetest' From 92288bbf1e7f6d15dda59280efcc45695520769d Mon Sep 17 00:00:00 2001 From: Lie Ryan Date: Sun, 26 Sep 2021 18:11:59 +1000 Subject: [PATCH 4/5] Remove duplicated method There is already a third copy of redefinition of _handle_conditional_node() --- rope/refactor/extract.py | 16 ---------------- 1 file changed, 16 deletions(-) diff --git a/rope/refactor/extract.py b/rope/refactor/extract.py index bc90ee02c..c542dd16c 100644 --- a/rope/refactor/extract.py +++ b/rope/refactor/extract.py @@ -868,22 +868,6 @@ def _comp_exp(self, node): self.written = self.written - comp_names | written self.maybe_written = self.maybe_written - comp_names | maybe_written - def _handle_conditional_node(self, node): - self.conditional = True - try: - for child in ast.get_child_nodes(node): - ast.walk(child, self) - finally: - self.conditional = False - - def _handle_conditional_node(self, node): - self.conditional = True - try: - for child in ast.get_child_nodes(node): - ast.walk(child, self) - finally: - self.conditional = False - def _If(self, node): self._handle_conditional_node(node) From 85489c6fd0abc1e52a52b00e565805438274530a Mon Sep 17 00:00:00 2001 From: Lie Ryan Date: Sun, 26 Sep 2021 18:13:36 +1000 Subject: [PATCH 5/5] Fix typo --- ropetest/refactor/extracttest.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/ropetest/refactor/extracttest.py b/ropetest/refactor/extracttest.py index 1d3c2ed83..f4572ed50 100644 --- a/ropetest/refactor/extracttest.py +++ b/ropetest/refactor/extracttest.py @@ -1979,7 +1979,7 @@ def second_method(someargs): self.assertEqual(expected, refactored) - def test_extract_with_list_compehention(self): + def test_extract_with_list_comprehension(self): code = dedent("""\ def f(): y = [1,2,3,4] @@ -2043,7 +2043,7 @@ def _a(y): """) self.assertEqual(expected, refactored) - def test_extract_with_set_compehention(self): + def test_extract_with_set_comprehension(self): code = dedent("""\ def f(): y = [1,2,3,4] @@ -2075,7 +2075,7 @@ def _a(y): """) self.assertEqual(expected, refactored) - def test_extract_with_dict_compehention(self): + def test_extract_with_dict_comprehension(self): code = dedent("""\ def f(): y = [1,2,3,4]