From a114efd92941b6d96b5956c7ec77473dd1a25af7 Mon Sep 17 00:00:00 2001 From: climbus Date: Sat, 2 Oct 2021 14:28:09 +0200 Subject: [PATCH 01/20] using get_inner_scope_for_offset --- rope/refactor/rename.py | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/rope/refactor/rename.py b/rope/refactor/rename.py index 2ea41a24e..61638c3ad 100644 --- a/rope/refactor/rename.py +++ b/rope/refactor/rename.py @@ -187,13 +187,8 @@ def get_old_name(self): return word_finder.get_primary_at(self.offset) def _get_scope_offset(self): - lines = self.pymodule.lines - scope = self.pymodule.get_scope().get_inner_scope_for_line( - lines.get_line_number(self.offset) - ) - start = lines.get_line_start(scope.get_start()) - end = lines.get_line_end(scope.get_end()) - return start, end + scope = self.pymodule.get_scope().get_inner_scope_for_offset(self.offset) + return scope.get_region() def get_changes(self, new_name, only_calls=False, reads=True, writes=True): changes = ChangeSet( From d221dc41f13e183d49fca5bcf154165630d83dc5 Mon Sep 17 00:00:00 2001 From: climbus Date: Mon, 4 Oct 2021 18:56:54 +0200 Subject: [PATCH 02/20] test for rename with list comprehension --- ropetest/refactor/renametest.py | 73 ++++++++++++++++++++++++--------- 1 file changed, 54 insertions(+), 19 deletions(-) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index 7afd3520f..ac5883e1e 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -115,10 +115,12 @@ def test_renaming_generator_comprehension_loop_variables(self): def test_renaming_comprehension_loop_variables_scope(self): # FIXME: variable scoping for comprehensions is incorrect, we currently # don't create a scope for comprehension - code = dedent("""\ + code = dedent( + """\ [b_var for b_var, c_var in d_var if b_var == c_var] b_var = 10 - """) + """ + ) refactored = self._local_rename(code, code.index("b_var") + 1, "new_var") self.assertEqual( "[new_var for new_var, c_var in d_var if new_var == c_var]\nb_var = 10\n", @@ -127,16 +129,20 @@ def test_renaming_comprehension_loop_variables_scope(self): @testutils.only_for_versions_higher("3.8") def test_renaming_inline_assignment(self): - code = dedent("""\ + code = dedent( + """\ while a_var := next(foo): print(a_var) - """) + """ + ) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ while new_var := next(foo): print(new_var) - """), + """ + ), refactored, ) @@ -178,27 +184,35 @@ def test_renaming_with_backslash_continued_names(self): @testutils.only_for("3.6") def test_renaming_occurrence_in_f_string(self): - code = dedent("""\ + code = dedent( + """\ a_var = 20 a_string=f'value: {a_var}' - """) - expected = dedent("""\ + """ + ) + expected = dedent( + """\ new_var = 20 a_string=f'value: {new_var}' - """) + """ + ) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) - @testutils.only_for('3.6') + @testutils.only_for("3.6") def test_renaming_occurrence_in_nested_f_string(self): - code = dedent("""\ + code = dedent( + """\ a_var = 20 a_string=f'{f"{a_var}"}' - """) - expected = dedent("""\ + """ + ) + expected = dedent( + """\ new_var = 20 a_string=f'{f"{new_var}"}' - """) + """ + ) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) @@ -746,21 +760,25 @@ def test_renaming_occurrences_in_overwritten_scopes2(self): @testutils.only_for_versions_higher("3.5") def test_renaming_in_generalized_dict_unpacking(self): - code = dedent("""\ + code = dedent( + """\ a_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in a_var: print("ya") - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") - expected = dedent("""\ + expected = dedent( + """\ new_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in new_var: print("ya") - """) + """ + ) self.assertEqual(expected, refactored) def test_dos_line_ending_and_renaming(self): @@ -859,6 +877,23 @@ def test_only_performing_on_reads(self): changer.get_changes("b", writes=False).do() self.assertEqual("a = 1\nb = 2\nprint(b)\n", self.mod.read()) + def test_rename_in_list_comprehension(self): + code = dedent( + """\ + some_var = 1 + compr = [some_var for some_var in range(10)] + """ + ) + offset = code.index("some_var") + refactored = self._local_rename(code, offset, "new_var") + expected = dedent( + """\ + new_var = 1 + compr = [some_var for some_var in range(10)] + """ + ) + self.assertEqual(refactored, expected) + class ImplicitInterfacesTest(unittest.TestCase): def setUp(self): From f3d453307afec4289d547c3271b7aea5dfcc63e8 Mon Sep 17 00:00:00 2001 From: climbus Date: Tue, 5 Oct 2021 12:12:34 +0200 Subject: [PATCH 03/20] fixed test --- ropetest/refactor/renametest.py | 34 ++++++++++++++++----------------- 1 file changed, 17 insertions(+), 17 deletions(-) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index ac5883e1e..1d66d72ce 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -828,6 +828,23 @@ def xxx_test_with_statement_variables_should_not_leak(self): expected = 'f = 1\nwith open("1.txt") as file:\n print(file)\n' self.assertEqual(expected, mod1.read()) + def test_rename_in_list_comprehension(self): + code = dedent( + """\ + some_var = 1 + compr = [some_var for some_var in range(10)] + """ + ) + offset = code.index("some_var") + refactored = self._local_rename(code, offset, "new_var") + expected = dedent( + """\ + new_var = 1 + compr = [some_var for some_var in range(10)] + """ + ) + self.assertEqual(refactored, expected) + class ChangeOccurrencesTest(unittest.TestCase): def setUp(self): @@ -877,23 +894,6 @@ def test_only_performing_on_reads(self): changer.get_changes("b", writes=False).do() self.assertEqual("a = 1\nb = 2\nprint(b)\n", self.mod.read()) - def test_rename_in_list_comprehension(self): - code = dedent( - """\ - some_var = 1 - compr = [some_var for some_var in range(10)] - """ - ) - offset = code.index("some_var") - refactored = self._local_rename(code, offset, "new_var") - expected = dedent( - """\ - new_var = 1 - compr = [some_var for some_var in range(10)] - """ - ) - self.assertEqual(refactored, expected) - class ImplicitInterfacesTest(unittest.TestCase): def setUp(self): From 5470908c20a5d333ffbca56c6e3f350f699964c6 Mon Sep 17 00:00:00 2001 From: climbus Date: Wed, 6 Oct 2021 14:24:18 +0200 Subject: [PATCH 04/20] get holding scope by offset --- rope/base/evaluate.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/rope/base/evaluate.py b/rope/base/evaluate.py index 48c8fe2b1..06686b0c9 100644 --- a/rope/base/evaluate.py +++ b/rope/base/evaluate.py @@ -84,7 +84,9 @@ def get_pyname_at(self, offset): def get_primary_and_pyname_at(self, offset): lineno = self.lines.get_line_number(offset) - holding_scope = self.module_scope.get_inner_scope_for_line(lineno) + holding_scope = self.module_scope.get_inner_scope_for_line( + lineno + ) # self.module_scope.get_inner_scope_for_offset(offset) # function keyword parameter if self.worder.is_function_keyword_parameter(offset): keyword_name = self.worder.get_word_at(offset) From e83c419fdccd6b63b65b5bf58257e66c1394d5a7 Mon Sep 17 00:00:00 2001 From: climbus Date: Wed, 6 Oct 2021 14:33:44 +0200 Subject: [PATCH 05/20] fixed some issues with getting scope regions --- rope/base/pyscopes.py | 16 ++++++++++---- rope/refactor/patchedast.py | 11 +++------- ropetest/pyscopestest.py | 42 +++++++++++++++++++++++++++++++++++++ 3 files changed, 57 insertions(+), 12 deletions(-) diff --git a/rope/base/pyscopes.py b/rope/base/pyscopes.py index 25a850696..d7ef36698 100644 --- a/rope/base/pyscopes.py +++ b/rope/base/pyscopes.py @@ -101,11 +101,9 @@ def get_logical_end(self): def get_kind(self): pass - @utils.saveit def get_region(self): - node = patchedast.patch_ast( - self.pyobject.get_ast(), self.pyobject.get_module().source_code - ) + self.pyobject.get_module().get_scope().get_region() + node = self.pyobject.get_ast() region = patchedast.node_region(node) return region @@ -135,6 +133,16 @@ def get_name(self, name): return self.builtin_names[name] raise exceptions.NameNotFoundError("name %s not found" % name) + @utils.saveit + def get_region(self): + source = self._get_source() + node = patchedast.patch_ast(self.pyobject.get_ast(), source) + region = patchedast.node_region(node) + return region + + def _get_source(self): + return self.pyobject.source_code + def get_names(self): if self.names.get() is None: result = dict(self.builtin_names) diff --git a/rope/refactor/patchedast.py b/rope/refactor/patchedast.py index 36ce4a3a6..5a8c59dd7 100644 --- a/rope/refactor/patchedast.py +++ b/rope/refactor/patchedast.py @@ -97,14 +97,6 @@ def __call__(self, node): node.sorted_children = ast.get_children(node) def _handle(self, node, base_children, eat_parens=False, eat_spaces=False): - if hasattr(node, "region"): - # ???: The same node was seen twice; what should we do? - warnings.warn( - "Node <%s> has been already patched; please report!" - % node.__class__.__name__, - RuntimeWarning, - ) - return base_children = collections.deque(base_children) self.children_stack.append(base_children) children = collections.deque() @@ -884,6 +876,9 @@ def _With(self, node): children.extend(node.body) self._handle(node, children) + def _AsyncWith(self, node): + return self._With(node) + def _child_nodes(self, nodes, separator): children = [] for index, child in enumerate(nodes): diff --git a/ropetest/pyscopestest.py b/ropetest/pyscopestest.py index 0003be260..b38059c83 100644 --- a/ropetest/pyscopestest.py +++ b/ropetest/pyscopestest.py @@ -3,6 +3,8 @@ except ImportError: import unittest +from textwrap import dedent + from rope.base import libutils from rope.base.pyobjects import get_base_type from ropetest import testutils @@ -328,6 +330,14 @@ def test_get_scope_for_offset_for_scope_with_indent(self): inner_scope = scope.get_scopes()[0] self.assertEqual(inner_scope, scope.get_inner_scope_for_offset(10)) + def test_get_scope_for_offset_for_function_scope_and_async_with_statement(self): + scope = libutils.get_string_scope( + self.project, + "async def func():\n async with a_func() as var:\n print(var)\n", + ) + inner_scope = scope.get_scopes()[0] + self.assertEqual(inner_scope, scope.get_inner_scope_for_offset(27)) + def test_getting_overwritten_scopes(self): scope = libutils.get_string_scope( self.project, "def f():\n pass\ndef f():\n pass\n" @@ -414,3 +424,35 @@ def test_get_inner_scope_for_nested_list_comprhension(self): self.assertEqual(len(scope.get_scopes()[0].get_scopes()), 1) self.assertIn("j", scope.get_scopes()[0].get_scopes()[0]) self.assertIn("i", scope.get_scopes()[0].get_scopes()[0]) + + def test_get_scope_region(self): + scope = libutils.get_string_scope( + self.project, + dedent( + """ + def func1(ala): + pass + + def func2(o): + pass""" + ), + ) + + self.assertEqual(scope.get_region(), (0, 47)) + self.assertEqual(scope.get_scopes()[0].get_region(), (1, 24)) + self.assertEqual(scope.get_scopes()[1].get_region(), (26, 47)) + + def test_only_get_inner_scope_region(self): + scope = libutils.get_string_scope( + self.project, + dedent( + """ + def func1(ala): + pass + + def func2(o): + pass""" + ), + ) + + self.assertEqual(scope.get_scopes()[1].get_region(), (26, 47)) From 7356fe6f9b44e97ee2e318f93d0c9358ca3c464b Mon Sep 17 00:00:00 2001 From: climbus Date: Wed, 6 Oct 2021 14:56:04 +0200 Subject: [PATCH 06/20] some refactorings --- rope/base/pyscopes.py | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/rope/base/pyscopes.py b/rope/base/pyscopes.py index d7ef36698..2d2a5d93d 100644 --- a/rope/base/pyscopes.py +++ b/rope/base/pyscopes.py @@ -102,11 +102,14 @@ def get_kind(self): pass def get_region(self): - self.pyobject.get_module().get_scope().get_region() + self._calculate_scope_regions_for_module() node = self.pyobject.get_ast() region = patchedast.node_region(node) return region + def _calculate_scope_regions_for_module(self): + self._get_global_scope().calculate_scope_regions() + def in_region(self, offset): """Checks if offset is in scope region""" @@ -134,11 +137,9 @@ def get_name(self, name): raise exceptions.NameNotFoundError("name %s not found" % name) @utils.saveit - def get_region(self): + def calculate_scope_regions(self): source = self._get_source() - node = patchedast.patch_ast(self.pyobject.get_ast(), source) - region = patchedast.node_region(node) - return region + patchedast.patch_ast(self.pyobject.get_ast(), source) def _get_source(self): return self.pyobject.source_code From 6c1c50b110e29dc45aa9c87b802065b0d7393083 Mon Sep 17 00:00:00 2001 From: climbus Date: Wed, 6 Oct 2021 14:59:34 +0200 Subject: [PATCH 07/20] exclude async with test for python < 3.5 --- ropetest/pyscopestest.py | 1 + 1 file changed, 1 insertion(+) diff --git a/ropetest/pyscopestest.py b/ropetest/pyscopestest.py index b38059c83..52434660f 100644 --- a/ropetest/pyscopestest.py +++ b/ropetest/pyscopestest.py @@ -330,6 +330,7 @@ def test_get_scope_for_offset_for_scope_with_indent(self): inner_scope = scope.get_scopes()[0] self.assertEqual(inner_scope, scope.get_inner_scope_for_offset(10)) + @testutils.only_for("3.5") def test_get_scope_for_offset_for_function_scope_and_async_with_statement(self): scope = libutils.get_string_scope( self.project, From 388feec6da9cfab9001cfa21f5c844ae8b6684f5 Mon Sep 17 00:00:00 2001 From: climbus Date: Wed, 6 Oct 2021 20:38:09 +0200 Subject: [PATCH 08/20] working rename in list comp scope --- rope/base/evaluate.py | 4 +--- rope/base/pyscopes.py | 4 ++-- ropetest/codeanalyzetest.py | 17 +++++++++++++++-- 3 files changed, 18 insertions(+), 7 deletions(-) diff --git a/rope/base/evaluate.py b/rope/base/evaluate.py index 06686b0c9..f9a17b5ae 100644 --- a/rope/base/evaluate.py +++ b/rope/base/evaluate.py @@ -84,9 +84,7 @@ def get_pyname_at(self, offset): def get_primary_and_pyname_at(self, offset): lineno = self.lines.get_line_number(offset) - holding_scope = self.module_scope.get_inner_scope_for_line( - lineno - ) # self.module_scope.get_inner_scope_for_offset(offset) + holding_scope = self.module_scope.get_inner_scope_for_offset(offset) # function keyword parameter if self.worder.is_function_keyword_parameter(offset): keyword_name = self.worder.get_word_at(offset) diff --git a/rope/base/pyscopes.py b/rope/base/pyscopes.py index 2d2a5d93d..301e09ca8 100644 --- a/rope/base/pyscopes.py +++ b/rope/base/pyscopes.py @@ -190,8 +190,8 @@ def _visit_comprehension(self): new_visitor = self.visitor(self.pycore, self.pyobject) for node in ast.get_child_nodes(self.pyobject.get_ast()): ast.walk(node, new_visitor) - self.names = new_visitor.names - self.names.update(self.parent.get_names()) + self.names = dict(self.parent.get_names()) + self.names.update(new_visitor.names) self.defineds = new_visitor.defineds def get_logical_end(self): diff --git a/ropetest/codeanalyzetest.py b/ropetest/codeanalyzetest.py index 96d2f7857..ff1e73e23 100644 --- a/ropetest/codeanalyzetest.py +++ b/ropetest/codeanalyzetest.py @@ -502,6 +502,17 @@ def test_one_liners_with_line_breaks2(self): pyname = name_finder.get_pyname_at(code.rindex("var")) self.assertEqual(pymod["var"], pyname) + def test_var_in_list_comprehension_differs_from_var_outside(self): + code = "var = 1\n[var for var in range(1)]\n" + pymod = libutils.get_string_module(self.project, code) + + name_finder = rope.base.evaluate.ScopeNameFinder(pymod) + + outside_pyname = name_finder.get_pyname_at(code.index("var")) + inside_pyname = name_finder.get_pyname_at(code.rindex("var")) + + self.assertNotEqual(outside_pyname, inside_pyname) + class LogicalLineFinderTest(unittest.TestCase): def setUp(self): @@ -623,7 +634,8 @@ def test_generating_line_starts_and_unmatched_deindents(self): self.assertEqual([4, 5], list(line_finder.generate_starts(4))) def test_false_triple_quoted_string(self): - code = dedent("""\ + code = dedent( + """\ def foo(): a = 0 p = 'foo''' @@ -631,7 +643,8 @@ def foo(): def bar(): a = 1 a += 1 - """) + """ + ) line_finder = self._logical_finder(code) self.assertEqual([1, 2, 3, 5, 6, 7], list(line_finder.generate_starts())) self.assertEqual((3, 3), line_finder.logical_line_in(3)) From fb05b152ba50ec7051852f18ff9e85371f1f93ee Mon Sep 17 00:00:00 2001 From: climbus Date: Wed, 6 Oct 2021 20:41:33 +0200 Subject: [PATCH 09/20] black renametest --- ropetest/refactor/renametest.py | 878 +++++++++++++++++++++----------- 1 file changed, 585 insertions(+), 293 deletions(-) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index d3beea82c..db5744958 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -41,138 +41,170 @@ def test_simple_global_variable_renaming(self): def test_variable_renaming_only_in_its_scope(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 20 def a_func(): a_var = 10 - """), + """ + ), 32, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ a_var = 20 def a_func(): new_var = 10 - """), + """ + ), refactored, ) def test_not_renaming_dot_name(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ replace = True 'aaa'.replace('a', 'b') - """), + """ + ), 1, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = True 'aaa'.replace('a', 'b') - """), + """ + ), refactored, ) def test_renaming_multiple_names_in_the_same_line(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 10 a_var = 10 + a_var / 2 - """), + """ + ), 2, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 10 new_var = 10 + new_var / 2 - """), + """ + ), refactored, ) def test_renaming_names_when_getting_some_attribute(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 'a b c' a_var.split('\\n') - """), + """ + ), 2, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 'a b c' new_var.split('\\n') - """), + """ + ), refactored, ) def test_renaming_names_when_getting_some_attribute2(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 'a b c' a_var.split('\\n') - """), + """ + ), 20, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 'a b c' new_var.split('\\n') - """), + """ + ), refactored, ) def test_renaming_function_parameters1(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ def f(a_param): print(a_param) - """), + """ + ), 8, "new_param", ) self.assertEqual( - dedent("""\ + dedent( + """\ def f(new_param): print(new_param) - """), + """ + ), refactored, ) def test_renaming_function_parameters2(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ def f(a_param): print(a_param) - """), + """ + ), 30, "new_param", ) self.assertEqual( - dedent("""\ + dedent( + """\ def f(new_param): print(new_param) - """), + """ + ), refactored, ) def test_renaming_occurrences_inside_functions(self): - code = dedent("""\ + code = dedent( + """\ def a_func(p1): a = p1 a_func(1) - """) + """ + ) refactored = self._local_rename(code, code.index("p1") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): a = new_param a_func(1) - """), + """ + ), refactored, ) @@ -211,10 +243,12 @@ def test_renaming_comprehension_loop_variables_scope(self): ) refactored = self._local_rename(code, code.index("b_var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ [new_var for new_var, c_var in d_var if new_var == c_var] b_var = 10 - """), + """ + ), refactored, ) @@ -238,65 +272,81 @@ def test_renaming_inline_assignment(self): ) def test_renaming_arguments_for_normal_args_changing_calls(self): - code = dedent("""\ + code = dedent( + """\ def a_func(p1=None, p2=None): pass a_func(p2=1) - """) + """ + ) refactored = self._local_rename(code, code.index("p2") + 1, "p3") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(p1=None, p3=None): pass a_func(p3=1) - """), + """ + ), refactored, ) def test_renaming_function_parameters_of_class_init(self): - code = dedent("""\ + code = dedent( + """\ class A(object): def __init__(self, a_param): pass a_var = A(a_param=1) - """) + """ + ) refactored = self._local_rename(code, code.index("a_param") + 1, "new_param") - expected = dedent("""\ + expected = dedent( + """\ class A(object): def __init__(self, new_param): pass a_var = A(new_param=1) - """) + """ + ) self.assertEqual(expected, refactored) def test_rename_functions_parameters_and_occurences_in_other_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent("""\ + dedent( + """\ def a_func(a_param): print(a_param) - """) + """ + ) ) mod2.write( - dedent("""\ + dedent( + """\ from mod1 import a_func a_func(a_param=10) - """) + """ + ) ) self._rename(mod1, mod1.read().index("a_param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ from mod1 import a_func a_func(new_param=10) - """), + """ + ), mod2.read(), ) @@ -346,91 +396,112 @@ def test_not_renaming_string_contents_in_f_string(self): "a_var = 20\na_string=f'{\"a_var\"}'\n", 2, "new_var" ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 20 a_string=f'{"a_var"}' - """), + """ + ), refactored, ) def test_not_renaming_string_contents(self): refactored = self._local_rename("a_var = 20\na_string='a_var'\n", 2, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 20 a_string='a_var' - """), + """ + ), refactored, ) def test_not_renaming_comment_contents(self): refactored = self._local_rename("a_var = 20\n# a_var\n", 2, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 20 # a_var - """), + """ + ), refactored, ) def test_renaming_all_occurrences_in_containing_scope(self): - code = dedent("""\ + code = dedent( + """\ if True: a_var = 1 else: a_var = 20 - """) + """ + ) refactored = self._local_rename(code, 16, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ if True: new_var = 1 else: new_var = 20 - """), + """ + ), refactored, ) def test_renaming_a_variable_with_arguement_name(self): - code = dedent("""\ + code = dedent( + """\ a_var = 10 def a_func(a_var): print(a_var) - """) + """ + ) refactored = self._local_rename(code, 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 10 def a_func(a_var): print(a_var) - """), + """ + ), refactored, ) def test_renaming_an_arguement_with_variable_name(self): - code = dedent("""\ + code = dedent( + """\ a_var = 10 def a_func(a_var): print(a_var) - """) + """ + ) refactored = self._local_rename(code, len(code) - 3, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ a_var = 10 def a_func(new_var): print(new_var) - """), + """ + ), refactored, ) def test_renaming_function_with_local_variable_name(self): - code = dedent("""\ + code = dedent( + """\ def a_func(): a_func=20 - a_func()""") + a_func()""" + ) refactored = self._local_rename(code, len(code) - 3, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): a_func=20 new_func()""" @@ -439,30 +510,37 @@ def new_func(): ) def test_renaming_functions(self): - code = dedent("""\ + code = dedent( + """\ def a_func(): pass a_func() - """) + """ + ) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), refactored, ) @testutils.only_for("3.5") def test_renaming_async_function(self): - code = dedent("""\ + code = dedent( + """\ async def a_func(): pass - a_func()""") + a_func()""" + ) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ async def new_func(): pass new_func()""" @@ -472,14 +550,17 @@ async def new_func(): @testutils.only_for("3.5") def test_renaming_await(self): - code = dedent("""\ + code = dedent( + """\ async def b_func(): pass async def a_func(): - await b_func()""") + await b_func()""" + ) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ async def new_func(): pass async def a_func(): @@ -491,142 +572,176 @@ async def a_func(): def test_renaming_functions_across_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 mod1.a_func() - """) + """ + ) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 mod1.new_func() - """), + """ + ), mod2.read(), ) def test_renaming_functions_across_modules_from_import(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ from mod1 import a_func a_func() - """) + """ + ) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ from mod1 import new_func new_func() - """), + """ + ), mod2.read(), ) def test_renaming_functions_from_another_module(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 mod1.a_func() - """) + """ + ) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 mod1.new_func() - """), + """ + ), mod2.read(), ) def test_applying_all_changes_together(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ import mod2 mod2.a_func() - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ import mod2 mod2.new_func() - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), mod2.read(), ) def test_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -639,17 +754,21 @@ def a_func(): def test_renaming_modules_aliased(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 as m m.a_func() - """) + """ + ) ) self._rename(mod1, None, "newmod") self.assertTrue( @@ -661,10 +780,12 @@ def test_renaming_packages(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2", pkg) mod2.write("from pkg.mod1 import a_func\n") @@ -676,54 +797,67 @@ def a_func(): def test_module_dependencies(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ class AClass(object): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() - """) + """ + ) ) self.project.get_pymodule(mod2).get_attributes()["mod1"] mod1.write( - dedent("""\ + dedent( + """\ def AClass(): return 0 - """) + """ + ) ) self._rename(mod2, len(mod2.read()) - 3, "a_func") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(): return 0 - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.a_func() - """), + """ + ), mod2.read(), ) def test_renaming_class_attributes(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ class AClass(object): def __init__(self): self.an_attr = 10 - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() another_var = a_var.an_attr""" @@ -732,35 +866,41 @@ def __init__(self): self._rename(mod1, mod1.read().index("an_attr"), "attr") self.assertEqual( - dedent("""\ + dedent( + """\ class AClass(object): def __init__(self): self.attr = 10 - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() another_var = a_var.attr""" ), - mod2.read() + mod2.read(), ) def test_renaming_class_attributes2(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ class AClass(object): def __init__(self): an_attr = 10 self.an_attr = 10 - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() another_var = a_var.an_attr""" @@ -769,16 +909,19 @@ def __init__(self): self._rename(mod1, mod1.read().rindex("an_attr"), "attr") self.assertEqual( - dedent("""\ + dedent( + """\ class AClass(object): def __init__(self): an_attr = 10 self.attr = 10 - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() another_var = a_var.attr""" @@ -789,35 +932,40 @@ def __init__(self): def test_renaming_methods_in_subclasses(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent("""\ + dedent( + """\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """) + """ + ) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent("""\ + dedent( + """\ class A(object): def new_method(self): pass class B(A): def new_method(self): pass - """), + """ + ), mod.read(), ) def test_renaming_methods_in_sibling_classes(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent("""\ + dedent( + """\ class A(object): def a_method(self): pass @@ -827,14 +975,16 @@ def a_method(self): class C(A): def a_method(self): pass - """) + """ + ) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent("""\ + dedent( + """\ class A(object): def new_method(self): pass @@ -844,65 +994,76 @@ def new_method(self): class C(A): def new_method(self): pass - """), + """ + ), mod.read(), ) def test_not_renaming_methods_in_hierarchies(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent("""\ + dedent( + """\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """) + """ + ) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=False ) self.assertEqual( - dedent("""\ + dedent( + """\ class A(object): def a_method(self): pass class B(A): def new_method(self): pass - """), + """ + ), mod.read(), ) def test_undoing_refactorings(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.project.history.undo() self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """), + """ + ), mod1.read(), ) def test_undoing_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -921,135 +1082,168 @@ def test_rename_in_module_renaming_one_letter_names_for_expressions(self): finder, "new_var", pymodule=pymod, replace_primary=True ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 10 print(1+new_var) - """), + """ + ), refactored, ) def test_renaming_for_loop_variable(self): - code = dedent("""\ + code = dedent( + """\ for var in range(10): print(var) - """) + """ + ) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ for new_var in range(10): print(new_var) - """), + """ + ), refactored, ) @testutils.only_for("3.5") def test_renaming_async_for_loop_variable(self): - code = dedent("""\ + code = dedent( + """\ async def func(): async for var in range(10): print(var) - """) + """ + ) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ async def func(): async for new_var in range(10): print(new_var) - """), + """ + ), refactored, ) @testutils.only_for("3.5") def test_renaming_async_with_context_manager(self): - code = dedent("""\ + code = dedent( + """\ def a_cm(): pass async def a_func(): - async with a_cm() as x: pass""") + async with a_cm() as x: pass""" + ) refactored = self._local_rename(code, code.find("a_cm") + 1, "another_cm") - expected = dedent("""\ + expected = dedent( + """\ def another_cm(): pass async def a_func(): - async with another_cm() as x: pass""") + async with another_cm() as x: pass""" + ) self.assertEqual(refactored, expected) @testutils.only_for("3.5") def test_renaming_async_with_as_variable(self): - code = dedent("""\ + code = dedent( + """\ async def func(): async with a_func() as var: print(var) - """) + """ + ) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ async def func(): async with a_func() as new_var: print(new_var) - """), + """ + ), refactored, ) def test_renaming_parameters(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) a_func(param=hey) - """) + """ + ) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) a_func(new_param=hey) - """), + """ + ), refactored, ) def test_renaming_assigned_parameters(self): - code = dedent("""\ + code = dedent( + """\ def f(p): p = p + 1 return p f(p=1) - """) + """ + ) refactored = self._local_rename(code, code.find("p"), "arg") self.assertEqual( - dedent("""\ + dedent( + """\ def f(arg): arg = arg + 1 return arg f(arg=1) - """), + """ + ), refactored, ) def test_renaming_parameters_not_renaming_others(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) param=10 a_func(param) - """) + """ + ) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) param=10 a_func(param) - """), + """ + ), refactored, ) def test_renaming_parameters_not_renaming_others2(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) param=10 - a_func(param=param)""") + a_func(param=param)""" + ) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) param=10 @@ -1059,82 +1253,102 @@ def a_func(new_param): ) def test_renaming_parameters_with_multiple_params(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """) + """ + ) refactored = self._local_rename(code, code.find("param1") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param, param2): print(new_param) a_func(new_param=1, param2=2) - """), + """ + ), refactored, ) def test_renaming_parameters_with_multiple_params2(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """) + """ + ) refactored = self._local_rename(code, code.rfind("param2") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(param1, new_param): print(param1) a_func(param1=1, new_param=2) - """), + """ + ), refactored, ) def test_renaming_parameters_on_calls(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) a_func(param = hey) - """) + """ + ) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) a_func(new_param = hey) - """), + """ + ), refactored, ) def test_renaming_parameters_spaces_before_call(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) a_func (param=hey) - """) + """ + ) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) a_func (new_param=hey) - """), + """ + ), refactored, ) def test_renaming_parameter_like_objects_after_keywords(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) dict(param=hey) - """) + """ + ) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) dict(param=hey) - """), + """ + ), refactored, ) @@ -1194,60 +1408,72 @@ def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): self.assertEqual("import newpkg\nmy_pkg = newpkg", mod1.read()) def test_renaming_global_variables(self): - code = dedent("""\ + code = dedent( + """\ a_var = 1 def a_func(): global a_var var = a_var - """) + """ + ) refactored = self._local_rename(code, code.index("a_var"), "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 def a_func(): global new_var var = new_var - """), + """ + ), refactored, ) def test_renaming_global_variables2(self): - code = dedent("""\ + code = dedent( + """\ a_var = 1 def a_func(): global a_var var = a_var - """) + """ + ) refactored = self._local_rename(code, code.rindex("a_var"), "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 def a_func(): global new_var var = new_var - """), + """ + ), refactored, ) def test_renaming_when_unsure(self): - code = dedent("""\ + code = dedent( + """\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent("""\ + dedent( + """\ class C(object): def new_func(self): pass def f(arg): arg.new_func() - """), + """ + ), mod1.read(), ) @@ -1258,29 +1484,34 @@ def test_renaming_when_unsure_with_confirmation(self): def confirm(occurrence): return False - code = dedent("""\ + code = dedent( + """\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=confirm) self.assertEqual( - dedent("""\ + dedent( + """\ class C(object): def new_func(self): pass def f(arg): arg.a_func() - """), + """ + ), mod1.read(), ) def test_renaming_when_unsure_not_renaming_knowns(self): - code = dedent("""\ + code = dedent( + """\ class C1(object): def a_func(self): pass @@ -1291,12 +1522,14 @@ def a_func(self): c1.a_func() c2 = C2() c2.a_func() - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent("""\ + dedent( + """\ class C1(object): def new_func(self): pass @@ -1307,92 +1540,111 @@ def a_func(self): c1.new_func() c2 = C2() c2.a_func() - """), + """ + ), mod1.read(), ) def test_renaming_in_strings_and_comments(self): - code = dedent("""\ + code = dedent( + """\ a_var = 1 # a_var - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 # new_var - """), + """ + ), mod1.read(), ) def test_not_renaming_in_strings_and_comments_where_not_visible(self): - code = dedent("""\ + code = dedent( + """\ def f(): a_var = 1 # a_var - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent("""\ + dedent( + """\ def f(): new_var = 1 # a_var - """), + """ + ), mod1.read(), ) def test_not_renaming_all_text_occurrences_in_strings_and_comments(self): - code = dedent("""\ + code = dedent( + """\ a_var = 1 # a_vard _a_var - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 # a_vard _a_var - """), + """ + ), mod1.read(), ) def test_renaming_occurrences_in_overwritten_scopes(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 20 def f(): print(a_var) def f(): print(a_var) - """), + """ + ), 2, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 20 def f(): print(new_var) def f(): print(new_var) - """), + """ + ), refactored, ) def test_renaming_occurrences_in_overwritten_scopes2(self): - code = dedent("""\ + code = dedent( + """\ def f(): a_var = 1 print(a_var) def f(): a_var = 1 print(a_var) - """) + """ + ) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual(code.replace("a_var", "new_var", 2), refactored) @@ -1440,30 +1692,38 @@ def test_resources_parameter(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent("""\ + dedent( + """\ def f(): pass - """) + """ + ) ) mod2.write( - dedent("""\ + dedent( + """\ import mod1 mod1.f() - """) + """ + ) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod1]) self.assertEqual( - dedent("""\ + dedent( + """\ def g(): pass - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 mod1.f() - """), + """ + ), mod2.read(), ) @@ -1471,51 +1731,63 @@ def test_resources_parameter_not_changing_defining_module(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent("""\ + dedent( + """\ def f(): pass - """) + """ + ) ) mod2.write( - dedent("""\ + dedent( + """\ import mod1 mod1.f() - """) + """ + ) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod2]) self.assertEqual( - dedent("""\ + dedent( + """\ def f(): pass - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 mod1.g() - """), + """ + ), mod2.read(), ) # XXX: with variables should not leak @testutils.only_for("2.5") def xxx_test_with_statement_variables_should_not_leak(self): - code = dedent("""\ + code = dedent( + """\ f = 1 with open("1.txt") as f: print(f) - """) + """ + ) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.rindex("f"), "file") - expected = dedent("""\ + expected = dedent( + """\ f = 1 with open("1.txt") as file: print(file) - """) + """ + ) self.assertEqual(expected, mod1.read()) def test_rename_in_list_comprehension(self): @@ -1547,91 +1819,107 @@ def tearDown(self): def test_simple_case(self): self.mod.write( - dedent("""\ + dedent( + """\ a_var = 1 print(a_var) - """) + """ + ) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().index("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 print(new_var) - """), + """ + ), self.mod.read(), ) def test_only_performing_inside_scopes(self): self.mod.write( - dedent("""\ + dedent( + """\ a_var = 1 new_var = 2 def f(): print(a_var) - """) + """ + ) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent("""\ + dedent( + """\ a_var = 1 new_var = 2 def f(): print(new_var) - """), + """ + ), self.mod.read(), ) def test_only_performing_on_calls(self): self.mod.write( - dedent("""\ + dedent( + """\ def f1(): pass def f2(): pass g = f1 a = f1() - """) + """ + ) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("f1") ) changer.get_changes("f2", only_calls=True).do() self.assertEqual( - dedent("""\ + dedent( + """\ def f1(): pass def f2(): pass g = f1 a = f2() - """), + """ + ), self.mod.read(), ) def test_only_performing_on_reads(self): self.mod.write( - dedent("""\ + dedent( + """\ a = 1 b = 2 print(a) - """) + """ + ) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a") ) changer.get_changes("b", writes=False).do() self.assertEqual( - dedent("""\ + dedent( + """\ a = 1 b = 2 print(b) - """), + """ + ), self.mod.read(), ) @@ -1655,7 +1943,8 @@ def _rename(self, resource, offset, new_name, **kwds): def test_performing_rename_on_parameters(self): self.mod1.write("def f(arg):\n arg.run()\n") self.mod2.write( - dedent("""\ + dedent( + """\ import mod1 @@ -1667,13 +1956,15 @@ def run(self): pass mod1.f(A()) mod1.f(B()) - """) + """ + ) ) self.pycore.analyze_module(self.mod2) self._rename(self.mod1, self.mod1.read().index("run"), "newrun") self.assertEqual("def f(arg):\n arg.newrun()\n", self.mod1.read()) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 @@ -1685,6 +1976,7 @@ def newrun(self): pass mod1.f(A()) mod1.f(B()) - """), + """ + ), self.mod2.read(), ) From 79e04d47c8101b4e932541a5e9511e875ad305c3 Mon Sep 17 00:00:00 2001 From: climbus Date: Wed, 6 Oct 2021 20:42:55 +0200 Subject: [PATCH 10/20] replaced failre decorator in test with list comp --- ropetest/refactor/renametest.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index db5744958..e26e79c88 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -231,10 +231,7 @@ def test_renaming_generator_comprehension_loop_variables(self): refactored, ) - @unittest.expectedFailure def test_renaming_comprehension_loop_variables_scope(self): - # FIXME: variable scoping for comprehensions is incorrect, we currently - # don't create a scope for comprehension code = dedent( """\ [b_var for b_var, c_var in d_var if b_var == c_var] From cf4b1a3cefe5fc2dba65714463938aee4c04f1a6 Mon Sep 17 00:00:00 2001 From: climbus Date: Wed, 6 Oct 2021 20:48:38 +0200 Subject: [PATCH 11/20] added to changelog --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index a8bddc012..b4bffb821 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,7 @@ - #398, #104 Fix parsing of nested `with` statement/context manager (@climbus) - #391, #376 Fix improper replacement when extracting attribute access expression with `similar=True` (@climbus) - #396 Fix improper replacement when extracting index access expression with `similar=True` (@lieryan) +- #293 Fix rename global var affects list comprehension (@climbus) ## Misc From e3851d128fd133d38478589eb6d8c3201cc7c5b4 Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 8 Oct 2021 08:59:38 +0200 Subject: [PATCH 12/20] fixed code formating --- ropetest/refactor/renametest.py | 966 +++++++++++--------------------- 1 file changed, 322 insertions(+), 644 deletions(-) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index e26e79c88..6d8f9cd08 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -41,170 +41,138 @@ def test_simple_global_variable_renaming(self): def test_variable_renaming_only_in_its_scope(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 20 def a_func(): a_var = 10 - """ - ), + """), 32, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ a_var = 20 def a_func(): new_var = 10 - """ - ), + """), refactored, ) def test_not_renaming_dot_name(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ replace = True 'aaa'.replace('a', 'b') - """ - ), + """), 1, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = True 'aaa'.replace('a', 'b') - """ - ), + """), refactored, ) def test_renaming_multiple_names_in_the_same_line(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 10 a_var = 10 + a_var / 2 - """ - ), + """), 2, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 10 new_var = 10 + new_var / 2 - """ - ), + """), refactored, ) def test_renaming_names_when_getting_some_attribute(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 'a b c' a_var.split('\\n') - """ - ), + """), 2, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 'a b c' new_var.split('\\n') - """ - ), + """), refactored, ) def test_renaming_names_when_getting_some_attribute2(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 'a b c' a_var.split('\\n') - """ - ), + """), 20, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 'a b c' new_var.split('\\n') - """ - ), + """), refactored, ) def test_renaming_function_parameters1(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ def f(a_param): print(a_param) - """ - ), + """), 8, "new_param", ) self.assertEqual( - dedent( - """\ + dedent("""\ def f(new_param): print(new_param) - """ - ), + """), refactored, ) def test_renaming_function_parameters2(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ def f(a_param): print(a_param) - """ - ), + """), 30, "new_param", ) self.assertEqual( - dedent( - """\ + dedent("""\ def f(new_param): print(new_param) - """ - ), + """), refactored, ) def test_renaming_occurrences_inside_functions(self): - code = dedent( - """\ + code = dedent("""\ def a_func(p1): a = p1 a_func(1) - """ - ) + """) refactored = self._local_rename(code, code.index("p1") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): a = new_param a_func(1) - """ - ), + """), refactored, ) @@ -232,118 +200,94 @@ def test_renaming_generator_comprehension_loop_variables(self): ) def test_renaming_comprehension_loop_variables_scope(self): - code = dedent( - """\ + code = dedent("""\ [b_var for b_var, c_var in d_var if b_var == c_var] b_var = 10 - """ - ) + """) refactored = self._local_rename(code, code.index("b_var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ [new_var for new_var, c_var in d_var if new_var == c_var] b_var = 10 - """ - ), + """), refactored, ) @testutils.only_for_versions_higher("3.8") def test_renaming_inline_assignment(self): - code = dedent( - """\ + code = dedent("""\ while a_var := next(foo): print(a_var) - """ - ) + """) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ while new_var := next(foo): print(new_var) - """ - ), + """), refactored, ) def test_renaming_arguments_for_normal_args_changing_calls(self): - code = dedent( - """\ + code = dedent("""\ def a_func(p1=None, p2=None): pass a_func(p2=1) - """ - ) + """) refactored = self._local_rename(code, code.index("p2") + 1, "p3") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(p1=None, p3=None): pass a_func(p3=1) - """ - ), + """), refactored, ) def test_renaming_function_parameters_of_class_init(self): - code = dedent( - """\ + code = dedent("""\ class A(object): def __init__(self, a_param): pass a_var = A(a_param=1) - """ - ) + """) refactored = self._local_rename(code, code.index("a_param") + 1, "new_param") - expected = dedent( - """\ + expected = dedent("""\ class A(object): def __init__(self, new_param): pass a_var = A(new_param=1) - """ - ) + """) self.assertEqual(expected, refactored) def test_rename_functions_parameters_and_occurences_in_other_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent( - """\ + dedent("""\ def a_func(a_param): print(a_param) - """ - ) + """) ) mod2.write( - dedent( - """\ + dedent("""\ from mod1 import a_func a_func(a_param=10) - """ - ) + """) ) self._rename(mod1, mod1.read().index("a_param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ from mod1 import a_func a_func(new_param=10) - """ - ), + """), mod2.read(), ) @@ -355,35 +299,27 @@ def test_renaming_with_backslash_continued_names(self): @testutils.only_for("3.6") def test_renaming_occurrence_in_f_string(self): - code = dedent( - """\ + code = dedent("""\ a_var = 20 a_string=f'value: {a_var}' - """ - ) - expected = dedent( - """\ + """) + expected = dedent("""\ new_var = 20 a_string=f'value: {new_var}' - """ - ) + """) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) @testutils.only_for("3.6") def test_renaming_occurrence_in_nested_f_string(self): - code = dedent( - """\ + code = dedent("""\ a_var = 20 a_string=f'{f"{a_var}"}' - """ - ) - expected = dedent( - """\ + """) + expected = dedent("""\ new_var = 20 a_string=f'{f"{new_var}"}' - """ - ) + """) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) @@ -393,352 +329,284 @@ def test_not_renaming_string_contents_in_f_string(self): "a_var = 20\na_string=f'{\"a_var\"}'\n", 2, "new_var" ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 a_string=f'{"a_var"}' - """ - ), + """), refactored, ) def test_not_renaming_string_contents(self): refactored = self._local_rename("a_var = 20\na_string='a_var'\n", 2, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 a_string='a_var' - """ - ), + """), refactored, ) def test_not_renaming_comment_contents(self): refactored = self._local_rename("a_var = 20\n# a_var\n", 2, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 # a_var - """ - ), + """), refactored, ) def test_renaming_all_occurrences_in_containing_scope(self): - code = dedent( - """\ + code = dedent("""\ if True: a_var = 1 else: a_var = 20 - """ - ) + """) refactored = self._local_rename(code, 16, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ if True: new_var = 1 else: new_var = 20 - """ - ), + """), refactored, ) def test_renaming_a_variable_with_arguement_name(self): - code = dedent( - """\ + code = dedent("""\ a_var = 10 def a_func(a_var): print(a_var) - """ - ) + """) refactored = self._local_rename(code, 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 10 def a_func(a_var): print(a_var) - """ - ), + """), refactored, ) def test_renaming_an_arguement_with_variable_name(self): - code = dedent( - """\ + code = dedent("""\ a_var = 10 def a_func(a_var): print(a_var) - """ - ) + """) refactored = self._local_rename(code, len(code) - 3, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ a_var = 10 def a_func(new_var): print(new_var) - """ - ), + """), refactored, ) def test_renaming_function_with_local_variable_name(self): - code = dedent( - """\ + code = dedent("""\ def a_func(): a_func=20 - a_func()""" - ) + a_func()""") refactored = self._local_rename(code, len(code) - 3, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): a_func=20 - new_func()""" - ), + new_func()"""), refactored, ) def test_renaming_functions(self): - code = dedent( - """\ + code = dedent("""\ def a_func(): pass a_func() - """ - ) + """) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), refactored, ) @testutils.only_for("3.5") def test_renaming_async_function(self): - code = dedent( - """\ + code = dedent("""\ async def a_func(): pass - a_func()""" - ) + a_func()""") refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ async def new_func(): pass - new_func()""" - ), + new_func()"""), refactored, ) @testutils.only_for("3.5") def test_renaming_await(self): - code = dedent( - """\ + code = dedent("""\ async def b_func(): pass async def a_func(): - await b_func()""" - ) + await b_func()""") refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ async def new_func(): pass async def a_func(): - await new_func()""" - ), + await new_func()"""), refactored, ) def test_renaming_functions_across_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.a_func() - """ - ) + """) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.new_func() - """ - ), + """), mod2.read(), ) def test_renaming_functions_across_modules_from_import(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ from mod1 import a_func a_func() - """ - ) + """) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ from mod1 import new_func new_func() - """ - ), + """), mod2.read(), ) def test_renaming_functions_from_another_module(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.a_func() - """ - ) + """) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.new_func() - """ - ), + """), mod2.read(), ) def test_applying_all_changes_together(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ import mod2 mod2.a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ import mod2 mod2.new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod2.read(), ) def test_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -751,21 +619,17 @@ def a_func(): def test_renaming_modules_aliased(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 as m m.a_func() - """ - ) + """) ) self._rename(mod1, None, "newmod") self.assertTrue( @@ -777,12 +641,10 @@ def test_renaming_packages(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2", pkg) mod2.write("from pkg.mod1 import a_func\n") @@ -794,175 +656,144 @@ def a_func(): def test_module_dependencies(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ class AClass(object): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - """ - ) + """) ) self.project.get_pymodule(mod2).get_attributes()["mod1"] mod1.write( - dedent( - """\ + dedent("""\ def AClass(): return 0 - """ - ) + """) ) self._rename(mod2, len(mod2.read()) - 3, "a_func") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(): return 0 - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.a_func() - """ - ), + """), mod2.read(), ) def test_renaming_class_attributes(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): self.an_attr = 10 - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - another_var = a_var.an_attr""" - ) + another_var = a_var.an_attr""") ) self._rename(mod1, mod1.read().index("an_attr"), "attr") self.assertEqual( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): self.attr = 10 - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - another_var = a_var.attr""" - ), + another_var = a_var.attr"""), mod2.read(), ) def test_renaming_class_attributes2(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): an_attr = 10 self.an_attr = 10 - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - another_var = a_var.an_attr""" - ) + another_var = a_var.an_attr""") ) self._rename(mod1, mod1.read().rindex("an_attr"), "attr") self.assertEqual( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): an_attr = 10 self.attr = 10 - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - another_var = a_var.attr""" - ), + another_var = a_var.attr"""), mod2.read(), ) def test_renaming_methods_in_subclasses(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """ - ) + """) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent( - """\ + dedent("""\ class A(object): def new_method(self): pass class B(A): def new_method(self): pass - """ - ), + """), mod.read(), ) def test_renaming_methods_in_sibling_classes(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass @@ -972,16 +803,14 @@ def a_method(self): class C(A): def a_method(self): pass - """ - ) + """) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent( - """\ + dedent("""\ class A(object): def new_method(self): pass @@ -991,76 +820,65 @@ def new_method(self): class C(A): def new_method(self): pass - """ - ), + """), mod.read(), ) def test_not_renaming_methods_in_hierarchies(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """ - ) + """) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=False ) self.assertEqual( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass class B(A): def new_method(self): pass - """ - ), + """), mod.read(), ) def test_undoing_refactorings(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.project.history.undo() self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ), + """), mod1.read(), ) def test_undoing_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -1079,273 +897,219 @@ def test_rename_in_module_renaming_one_letter_names_for_expressions(self): finder, "new_var", pymodule=pymod, replace_primary=True ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 10 print(1+new_var) - """ - ), + """), refactored, ) def test_renaming_for_loop_variable(self): - code = dedent( - """\ + code = dedent("""\ for var in range(10): print(var) - """ - ) + """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ for new_var in range(10): print(new_var) - """ - ), + """), refactored, ) @testutils.only_for("3.5") def test_renaming_async_for_loop_variable(self): - code = dedent( - """\ + code = dedent("""\ async def func(): async for var in range(10): print(var) - """ - ) + """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ async def func(): async for new_var in range(10): print(new_var) - """ - ), + """), refactored, ) @testutils.only_for("3.5") def test_renaming_async_with_context_manager(self): - code = dedent( - """\ + code = dedent("""\ def a_cm(): pass async def a_func(): - async with a_cm() as x: pass""" - ) + async with a_cm() as x: pass""") refactored = self._local_rename(code, code.find("a_cm") + 1, "another_cm") - expected = dedent( - """\ + expected = dedent("""\ def another_cm(): pass async def a_func(): - async with another_cm() as x: pass""" - ) + async with another_cm() as x: pass""") self.assertEqual(refactored, expected) @testutils.only_for("3.5") def test_renaming_async_with_as_variable(self): - code = dedent( - """\ + code = dedent("""\ async def func(): async with a_func() as var: print(var) - """ - ) + """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ async def func(): async with a_func() as new_var: print(new_var) - """ - ), + """), refactored, ) def test_renaming_parameters(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) a_func(param=hey) - """ - ) + """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) a_func(new_param=hey) - """ - ), + """), refactored, ) def test_renaming_assigned_parameters(self): - code = dedent( - """\ + code = dedent("""\ def f(p): p = p + 1 return p f(p=1) - """ - ) + """) refactored = self._local_rename(code, code.find("p"), "arg") self.assertEqual( - dedent( - """\ + dedent("""\ def f(arg): arg = arg + 1 return arg f(arg=1) - """ - ), + """), refactored, ) def test_renaming_parameters_not_renaming_others(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) param=10 a_func(param) - """ - ) + """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) param=10 a_func(param) - """ - ), + """), refactored, ) def test_renaming_parameters_not_renaming_others2(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) param=10 - a_func(param=param)""" - ) + a_func(param=param)""") refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) param=10 - a_func(new_param=param)""" - ), + a_func(new_param=param)"""), refactored, ) def test_renaming_parameters_with_multiple_params(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """ - ) + """) refactored = self._local_rename(code, code.find("param1") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param, param2): print(new_param) a_func(new_param=1, param2=2) - """ - ), + """), refactored, ) def test_renaming_parameters_with_multiple_params2(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """ - ) + """) refactored = self._local_rename(code, code.rfind("param2") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(param1, new_param): print(param1) a_func(param1=1, new_param=2) - """ - ), + """), refactored, ) def test_renaming_parameters_on_calls(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) a_func(param = hey) - """ - ) + """) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) a_func(new_param = hey) - """ - ), + """), refactored, ) def test_renaming_parameters_spaces_before_call(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) a_func (param=hey) - """ - ) + """) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) a_func (new_param=hey) - """ - ), + """), refactored, ) def test_renaming_parameter_like_objects_after_keywords(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) dict(param=hey) - """ - ) + """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) dict(param=hey) - """ - ), + """), refactored, ) @@ -1405,72 +1169,60 @@ def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): self.assertEqual("import newpkg\nmy_pkg = newpkg", mod1.read()) def test_renaming_global_variables(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 def a_func(): global a_var var = a_var - """ - ) + """) refactored = self._local_rename(code, code.index("a_var"), "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 def a_func(): global new_var var = new_var - """ - ), + """), refactored, ) def test_renaming_global_variables2(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 def a_func(): global a_var var = a_var - """ - ) + """) refactored = self._local_rename(code, code.rindex("a_var"), "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 def a_func(): global new_var var = new_var - """ - ), + """), refactored, ) def test_renaming_when_unsure(self): - code = dedent( - """\ + code = dedent("""\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent( - """\ + dedent("""\ class C(object): def new_func(self): pass def f(arg): arg.new_func() - """ - ), + """), mod1.read(), ) @@ -1481,34 +1233,29 @@ def test_renaming_when_unsure_with_confirmation(self): def confirm(occurrence): return False - code = dedent( - """\ + code = dedent("""\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=confirm) self.assertEqual( - dedent( - """\ + dedent("""\ class C(object): def new_func(self): pass def f(arg): arg.a_func() - """ - ), + """), mod1.read(), ) def test_renaming_when_unsure_not_renaming_knowns(self): - code = dedent( - """\ + code = dedent("""\ class C1(object): def a_func(self): pass @@ -1519,14 +1266,12 @@ def a_func(self): c1.a_func() c2 = C2() c2.a_func() - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent( - """\ + dedent("""\ class C1(object): def new_func(self): pass @@ -1537,135 +1282,112 @@ def a_func(self): c1.new_func() c2 = C2() c2.a_func() - """ - ), + """), mod1.read(), ) def test_renaming_in_strings_and_comments(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 # a_var - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 # new_var - """ - ), + """), mod1.read(), ) def test_not_renaming_in_strings_and_comments_where_not_visible(self): - code = dedent( - """\ + code = dedent("""\ def f(): a_var = 1 # a_var - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent( - """\ + dedent("""\ def f(): new_var = 1 # a_var - """ - ), + """), mod1.read(), ) def test_not_renaming_all_text_occurrences_in_strings_and_comments(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 # a_vard _a_var - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 # a_vard _a_var - """ - ), + """), mod1.read(), ) def test_renaming_occurrences_in_overwritten_scopes(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 20 def f(): print(a_var) def f(): print(a_var) - """ - ), + """), 2, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 def f(): print(new_var) def f(): print(new_var) - """ - ), + """), refactored, ) def test_renaming_occurrences_in_overwritten_scopes2(self): - code = dedent( - """\ + code = dedent("""\ def f(): a_var = 1 print(a_var) def f(): a_var = 1 print(a_var) - """ - ) + """) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual(code.replace("a_var", "new_var", 2), refactored) @testutils.only_for_versions_higher("3.5") def test_renaming_in_generalized_dict_unpacking(self): - code = dedent( - """\ + code = dedent("""\ a_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in a_var: print("ya") - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") - expected = dedent( - """\ + expected = dedent("""\ new_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in new_var: print("ya") - """ - ) + """) self.assertEqual(expected, refactored) def test_dos_line_ending_and_renaming(self): @@ -1689,38 +1411,30 @@ def test_resources_parameter(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent( - """\ + dedent("""\ def f(): pass - """ - ) + """) ) mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.f() - """ - ) + """) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod1]) self.assertEqual( - dedent( - """\ + dedent("""\ def g(): pass - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.f() - """ - ), + """), mod2.read(), ) @@ -1728,80 +1442,64 @@ def test_resources_parameter_not_changing_defining_module(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent( - """\ + dedent("""\ def f(): pass - """ - ) + """) ) mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.f() - """ - ) + """) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod2]) self.assertEqual( - dedent( - """\ + dedent("""\ def f(): pass - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.g() - """ - ), + """), mod2.read(), ) # XXX: with variables should not leak @testutils.only_for("2.5") def xxx_test_with_statement_variables_should_not_leak(self): - code = dedent( - """\ + code = dedent("""\ f = 1 with open("1.txt") as f: print(f) - """ - ) + """) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.rindex("f"), "file") - expected = dedent( - """\ + expected = dedent("""\ f = 1 with open("1.txt") as file: print(file) - """ - ) + """) self.assertEqual(expected, mod1.read()) def test_rename_in_list_comprehension(self): - code = dedent( - """\ + code = dedent("""\ some_var = 1 compr = [some_var for some_var in range(10)] - """ - ) + """) offset = code.index("some_var") refactored = self._local_rename(code, offset, "new_var") - expected = dedent( - """\ + expected = dedent("""\ new_var = 1 compr = [some_var for some_var in range(10)] - """ - ) + """) self.assertEqual(refactored, expected) @@ -1816,107 +1514,91 @@ def tearDown(self): def test_simple_case(self): self.mod.write( - dedent( - """\ + dedent("""\ a_var = 1 print(a_var) - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().index("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 print(new_var) - """ - ), + """), self.mod.read(), ) def test_only_performing_inside_scopes(self): self.mod.write( - dedent( - """\ + dedent("""\ a_var = 1 new_var = 2 def f(): print(a_var) - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent( - """\ + dedent("""\ a_var = 1 new_var = 2 def f(): print(new_var) - """ - ), + """), self.mod.read(), ) def test_only_performing_on_calls(self): self.mod.write( - dedent( - """\ + dedent("""\ def f1(): pass def f2(): pass g = f1 a = f1() - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("f1") ) changer.get_changes("f2", only_calls=True).do() self.assertEqual( - dedent( - """\ + dedent("""\ def f1(): pass def f2(): pass g = f1 a = f2() - """ - ), + """), self.mod.read(), ) def test_only_performing_on_reads(self): self.mod.write( - dedent( - """\ + dedent("""\ a = 1 b = 2 print(a) - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a") ) changer.get_changes("b", writes=False).do() self.assertEqual( - dedent( - """\ + dedent("""\ a = 1 b = 2 print(b) - """ - ), + """), self.mod.read(), ) @@ -1940,8 +1622,7 @@ def _rename(self, resource, offset, new_name, **kwds): def test_performing_rename_on_parameters(self): self.mod1.write("def f(arg):\n arg.run()\n") self.mod2.write( - dedent( - """\ + dedent("""\ import mod1 @@ -1953,15 +1634,13 @@ def run(self): pass mod1.f(A()) mod1.f(B()) - """ - ) + """) ) self.pycore.analyze_module(self.mod2) self._rename(self.mod1, self.mod1.read().index("run"), "newrun") self.assertEqual("def f(arg):\n arg.newrun()\n", self.mod1.read()) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 @@ -1973,7 +1652,6 @@ def newrun(self): pass mod1.f(A()) mod1.f(B()) - """ - ), + """), self.mod2.read(), ) From 62b0c9d0b6dcd0fd2110f9637ad51a68453db8d0 Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 8 Oct 2021 10:53:10 +0200 Subject: [PATCH 13/20] Revert "fixed code formating" This reverts commit e3851d128fd133d38478589eb6d8c3201cc7c5b4. --- ropetest/refactor/renametest.py | 966 +++++++++++++++++++++----------- 1 file changed, 644 insertions(+), 322 deletions(-) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index 6d8f9cd08..e26e79c88 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -41,138 +41,170 @@ def test_simple_global_variable_renaming(self): def test_variable_renaming_only_in_its_scope(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 20 def a_func(): a_var = 10 - """), + """ + ), 32, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ a_var = 20 def a_func(): new_var = 10 - """), + """ + ), refactored, ) def test_not_renaming_dot_name(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ replace = True 'aaa'.replace('a', 'b') - """), + """ + ), 1, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = True 'aaa'.replace('a', 'b') - """), + """ + ), refactored, ) def test_renaming_multiple_names_in_the_same_line(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 10 a_var = 10 + a_var / 2 - """), + """ + ), 2, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 10 new_var = 10 + new_var / 2 - """), + """ + ), refactored, ) def test_renaming_names_when_getting_some_attribute(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 'a b c' a_var.split('\\n') - """), + """ + ), 2, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 'a b c' new_var.split('\\n') - """), + """ + ), refactored, ) def test_renaming_names_when_getting_some_attribute2(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 'a b c' a_var.split('\\n') - """), + """ + ), 20, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 'a b c' new_var.split('\\n') - """), + """ + ), refactored, ) def test_renaming_function_parameters1(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ def f(a_param): print(a_param) - """), + """ + ), 8, "new_param", ) self.assertEqual( - dedent("""\ + dedent( + """\ def f(new_param): print(new_param) - """), + """ + ), refactored, ) def test_renaming_function_parameters2(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ def f(a_param): print(a_param) - """), + """ + ), 30, "new_param", ) self.assertEqual( - dedent("""\ + dedent( + """\ def f(new_param): print(new_param) - """), + """ + ), refactored, ) def test_renaming_occurrences_inside_functions(self): - code = dedent("""\ + code = dedent( + """\ def a_func(p1): a = p1 a_func(1) - """) + """ + ) refactored = self._local_rename(code, code.index("p1") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): a = new_param a_func(1) - """), + """ + ), refactored, ) @@ -200,94 +232,118 @@ def test_renaming_generator_comprehension_loop_variables(self): ) def test_renaming_comprehension_loop_variables_scope(self): - code = dedent("""\ + code = dedent( + """\ [b_var for b_var, c_var in d_var if b_var == c_var] b_var = 10 - """) + """ + ) refactored = self._local_rename(code, code.index("b_var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ [new_var for new_var, c_var in d_var if new_var == c_var] b_var = 10 - """), + """ + ), refactored, ) @testutils.only_for_versions_higher("3.8") def test_renaming_inline_assignment(self): - code = dedent("""\ + code = dedent( + """\ while a_var := next(foo): print(a_var) - """) + """ + ) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ while new_var := next(foo): print(new_var) - """), + """ + ), refactored, ) def test_renaming_arguments_for_normal_args_changing_calls(self): - code = dedent("""\ + code = dedent( + """\ def a_func(p1=None, p2=None): pass a_func(p2=1) - """) + """ + ) refactored = self._local_rename(code, code.index("p2") + 1, "p3") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(p1=None, p3=None): pass a_func(p3=1) - """), + """ + ), refactored, ) def test_renaming_function_parameters_of_class_init(self): - code = dedent("""\ + code = dedent( + """\ class A(object): def __init__(self, a_param): pass a_var = A(a_param=1) - """) + """ + ) refactored = self._local_rename(code, code.index("a_param") + 1, "new_param") - expected = dedent("""\ + expected = dedent( + """\ class A(object): def __init__(self, new_param): pass a_var = A(new_param=1) - """) + """ + ) self.assertEqual(expected, refactored) def test_rename_functions_parameters_and_occurences_in_other_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent("""\ + dedent( + """\ def a_func(a_param): print(a_param) - """) + """ + ) ) mod2.write( - dedent("""\ + dedent( + """\ from mod1 import a_func a_func(a_param=10) - """) + """ + ) ) self._rename(mod1, mod1.read().index("a_param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ from mod1 import a_func a_func(new_param=10) - """), + """ + ), mod2.read(), ) @@ -299,27 +355,35 @@ def test_renaming_with_backslash_continued_names(self): @testutils.only_for("3.6") def test_renaming_occurrence_in_f_string(self): - code = dedent("""\ + code = dedent( + """\ a_var = 20 a_string=f'value: {a_var}' - """) - expected = dedent("""\ + """ + ) + expected = dedent( + """\ new_var = 20 a_string=f'value: {new_var}' - """) + """ + ) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) @testutils.only_for("3.6") def test_renaming_occurrence_in_nested_f_string(self): - code = dedent("""\ + code = dedent( + """\ a_var = 20 a_string=f'{f"{a_var}"}' - """) - expected = dedent("""\ + """ + ) + expected = dedent( + """\ new_var = 20 a_string=f'{f"{new_var}"}' - """) + """ + ) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) @@ -329,284 +393,352 @@ def test_not_renaming_string_contents_in_f_string(self): "a_var = 20\na_string=f'{\"a_var\"}'\n", 2, "new_var" ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 20 a_string=f'{"a_var"}' - """), + """ + ), refactored, ) def test_not_renaming_string_contents(self): refactored = self._local_rename("a_var = 20\na_string='a_var'\n", 2, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 20 a_string='a_var' - """), + """ + ), refactored, ) def test_not_renaming_comment_contents(self): refactored = self._local_rename("a_var = 20\n# a_var\n", 2, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 20 # a_var - """), + """ + ), refactored, ) def test_renaming_all_occurrences_in_containing_scope(self): - code = dedent("""\ + code = dedent( + """\ if True: a_var = 1 else: a_var = 20 - """) + """ + ) refactored = self._local_rename(code, 16, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ if True: new_var = 1 else: new_var = 20 - """), + """ + ), refactored, ) def test_renaming_a_variable_with_arguement_name(self): - code = dedent("""\ + code = dedent( + """\ a_var = 10 def a_func(a_var): print(a_var) - """) + """ + ) refactored = self._local_rename(code, 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 10 def a_func(a_var): print(a_var) - """), + """ + ), refactored, ) def test_renaming_an_arguement_with_variable_name(self): - code = dedent("""\ + code = dedent( + """\ a_var = 10 def a_func(a_var): print(a_var) - """) + """ + ) refactored = self._local_rename(code, len(code) - 3, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ a_var = 10 def a_func(new_var): print(new_var) - """), + """ + ), refactored, ) def test_renaming_function_with_local_variable_name(self): - code = dedent("""\ + code = dedent( + """\ def a_func(): a_func=20 - a_func()""") + a_func()""" + ) refactored = self._local_rename(code, len(code) - 3, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): a_func=20 - new_func()"""), + new_func()""" + ), refactored, ) def test_renaming_functions(self): - code = dedent("""\ + code = dedent( + """\ def a_func(): pass a_func() - """) + """ + ) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), refactored, ) @testutils.only_for("3.5") def test_renaming_async_function(self): - code = dedent("""\ + code = dedent( + """\ async def a_func(): pass - a_func()""") + a_func()""" + ) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ async def new_func(): pass - new_func()"""), + new_func()""" + ), refactored, ) @testutils.only_for("3.5") def test_renaming_await(self): - code = dedent("""\ + code = dedent( + """\ async def b_func(): pass async def a_func(): - await b_func()""") + await b_func()""" + ) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ async def new_func(): pass async def a_func(): - await new_func()"""), + await new_func()""" + ), refactored, ) def test_renaming_functions_across_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 mod1.a_func() - """) + """ + ) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 mod1.new_func() - """), + """ + ), mod2.read(), ) def test_renaming_functions_across_modules_from_import(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ from mod1 import a_func a_func() - """) + """ + ) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ from mod1 import new_func new_func() - """), + """ + ), mod2.read(), ) def test_renaming_functions_from_another_module(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 mod1.a_func() - """) + """ + ) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 mod1.new_func() - """), + """ + ), mod2.read(), ) def test_applying_all_changes_together(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ import mod2 mod2.a_func() - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent("""\ + dedent( + """\ import mod2 mod2.new_func() - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ def new_func(): pass new_func() - """), + """ + ), mod2.read(), ) def test_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -619,17 +751,21 @@ def a_func(): def test_renaming_modules_aliased(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 as m m.a_func() - """) + """ + ) ) self._rename(mod1, None, "newmod") self.assertTrue( @@ -641,10 +777,12 @@ def test_renaming_packages(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2", pkg) mod2.write("from pkg.mod1 import a_func\n") @@ -656,144 +794,175 @@ def a_func(): def test_module_dependencies(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ class AClass(object): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() - """) + """ + ) ) self.project.get_pymodule(mod2).get_attributes()["mod1"] mod1.write( - dedent("""\ + dedent( + """\ def AClass(): return 0 - """) + """ + ) ) self._rename(mod2, len(mod2.read()) - 3, "a_func") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(): return 0 - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.a_func() - """), + """ + ), mod2.read(), ) def test_renaming_class_attributes(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ class AClass(object): def __init__(self): self.an_attr = 10 - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() - another_var = a_var.an_attr""") + another_var = a_var.an_attr""" + ) ) self._rename(mod1, mod1.read().index("an_attr"), "attr") self.assertEqual( - dedent("""\ + dedent( + """\ class AClass(object): def __init__(self): self.attr = 10 - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() - another_var = a_var.attr"""), + another_var = a_var.attr""" + ), mod2.read(), ) def test_renaming_class_attributes2(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ class AClass(object): def __init__(self): an_attr = 10 self.an_attr = 10 - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() - another_var = a_var.an_attr""") + another_var = a_var.an_attr""" + ) ) self._rename(mod1, mod1.read().rindex("an_attr"), "attr") self.assertEqual( - dedent("""\ + dedent( + """\ class AClass(object): def __init__(self): an_attr = 10 self.attr = 10 - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 a_var = mod1.AClass() - another_var = a_var.attr"""), + another_var = a_var.attr""" + ), mod2.read(), ) def test_renaming_methods_in_subclasses(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent("""\ + dedent( + """\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """) + """ + ) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent("""\ + dedent( + """\ class A(object): def new_method(self): pass class B(A): def new_method(self): pass - """), + """ + ), mod.read(), ) def test_renaming_methods_in_sibling_classes(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent("""\ + dedent( + """\ class A(object): def a_method(self): pass @@ -803,14 +972,16 @@ def a_method(self): class C(A): def a_method(self): pass - """) + """ + ) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent("""\ + dedent( + """\ class A(object): def new_method(self): pass @@ -820,65 +991,76 @@ def new_method(self): class C(A): def new_method(self): pass - """), + """ + ), mod.read(), ) def test_not_renaming_methods_in_hierarchies(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent("""\ + dedent( + """\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """) + """ + ) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=False ) self.assertEqual( - dedent("""\ + dedent( + """\ class A(object): def a_method(self): pass class B(A): def new_method(self): pass - """), + """ + ), mod.read(), ) def test_undoing_refactorings(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """) + """ + ) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.project.history.undo() self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(): pass a_func() - """), + """ + ), mod1.read(), ) def test_undoing_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent("""\ + dedent( + """\ def a_func(): pass - """) + """ + ) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -897,219 +1079,273 @@ def test_rename_in_module_renaming_one_letter_names_for_expressions(self): finder, "new_var", pymodule=pymod, replace_primary=True ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 10 print(1+new_var) - """), + """ + ), refactored, ) def test_renaming_for_loop_variable(self): - code = dedent("""\ + code = dedent( + """\ for var in range(10): print(var) - """) + """ + ) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ for new_var in range(10): print(new_var) - """), + """ + ), refactored, ) @testutils.only_for("3.5") def test_renaming_async_for_loop_variable(self): - code = dedent("""\ + code = dedent( + """\ async def func(): async for var in range(10): print(var) - """) + """ + ) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ async def func(): async for new_var in range(10): print(new_var) - """), + """ + ), refactored, ) @testutils.only_for("3.5") def test_renaming_async_with_context_manager(self): - code = dedent("""\ + code = dedent( + """\ def a_cm(): pass async def a_func(): - async with a_cm() as x: pass""") + async with a_cm() as x: pass""" + ) refactored = self._local_rename(code, code.find("a_cm") + 1, "another_cm") - expected = dedent("""\ + expected = dedent( + """\ def another_cm(): pass async def a_func(): - async with another_cm() as x: pass""") + async with another_cm() as x: pass""" + ) self.assertEqual(refactored, expected) @testutils.only_for("3.5") def test_renaming_async_with_as_variable(self): - code = dedent("""\ + code = dedent( + """\ async def func(): async with a_func() as var: print(var) - """) + """ + ) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ async def func(): async with a_func() as new_var: print(new_var) - """), + """ + ), refactored, ) def test_renaming_parameters(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) a_func(param=hey) - """) + """ + ) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) a_func(new_param=hey) - """), + """ + ), refactored, ) def test_renaming_assigned_parameters(self): - code = dedent("""\ + code = dedent( + """\ def f(p): p = p + 1 return p f(p=1) - """) + """ + ) refactored = self._local_rename(code, code.find("p"), "arg") self.assertEqual( - dedent("""\ + dedent( + """\ def f(arg): arg = arg + 1 return arg f(arg=1) - """), + """ + ), refactored, ) def test_renaming_parameters_not_renaming_others(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) param=10 a_func(param) - """) + """ + ) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) param=10 a_func(param) - """), + """ + ), refactored, ) def test_renaming_parameters_not_renaming_others2(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) param=10 - a_func(param=param)""") + a_func(param=param)""" + ) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) param=10 - a_func(new_param=param)"""), + a_func(new_param=param)""" + ), refactored, ) def test_renaming_parameters_with_multiple_params(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """) + """ + ) refactored = self._local_rename(code, code.find("param1") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param, param2): print(new_param) a_func(new_param=1, param2=2) - """), + """ + ), refactored, ) def test_renaming_parameters_with_multiple_params2(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """) + """ + ) refactored = self._local_rename(code, code.rfind("param2") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(param1, new_param): print(param1) a_func(param1=1, new_param=2) - """), + """ + ), refactored, ) def test_renaming_parameters_on_calls(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) a_func(param = hey) - """) + """ + ) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) a_func(new_param = hey) - """), + """ + ), refactored, ) def test_renaming_parameters_spaces_before_call(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) a_func (param=hey) - """) + """ + ) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) a_func (new_param=hey) - """), + """ + ), refactored, ) def test_renaming_parameter_like_objects_after_keywords(self): - code = dedent("""\ + code = dedent( + """\ def a_func(param): print(param) dict(param=hey) - """) + """ + ) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent("""\ + dedent( + """\ def a_func(new_param): print(new_param) dict(param=hey) - """), + """ + ), refactored, ) @@ -1169,60 +1405,72 @@ def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): self.assertEqual("import newpkg\nmy_pkg = newpkg", mod1.read()) def test_renaming_global_variables(self): - code = dedent("""\ + code = dedent( + """\ a_var = 1 def a_func(): global a_var var = a_var - """) + """ + ) refactored = self._local_rename(code, code.index("a_var"), "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 def a_func(): global new_var var = new_var - """), + """ + ), refactored, ) def test_renaming_global_variables2(self): - code = dedent("""\ + code = dedent( + """\ a_var = 1 def a_func(): global a_var var = a_var - """) + """ + ) refactored = self._local_rename(code, code.rindex("a_var"), "new_var") self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 def a_func(): global new_var var = new_var - """), + """ + ), refactored, ) def test_renaming_when_unsure(self): - code = dedent("""\ + code = dedent( + """\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent("""\ + dedent( + """\ class C(object): def new_func(self): pass def f(arg): arg.new_func() - """), + """ + ), mod1.read(), ) @@ -1233,29 +1481,34 @@ def test_renaming_when_unsure_with_confirmation(self): def confirm(occurrence): return False - code = dedent("""\ + code = dedent( + """\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=confirm) self.assertEqual( - dedent("""\ + dedent( + """\ class C(object): def new_func(self): pass def f(arg): arg.a_func() - """), + """ + ), mod1.read(), ) def test_renaming_when_unsure_not_renaming_knowns(self): - code = dedent("""\ + code = dedent( + """\ class C1(object): def a_func(self): pass @@ -1266,12 +1519,14 @@ def a_func(self): c1.a_func() c2 = C2() c2.a_func() - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent("""\ + dedent( + """\ class C1(object): def new_func(self): pass @@ -1282,112 +1537,135 @@ def a_func(self): c1.new_func() c2 = C2() c2.a_func() - """), + """ + ), mod1.read(), ) def test_renaming_in_strings_and_comments(self): - code = dedent("""\ + code = dedent( + """\ a_var = 1 # a_var - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 # new_var - """), + """ + ), mod1.read(), ) def test_not_renaming_in_strings_and_comments_where_not_visible(self): - code = dedent("""\ + code = dedent( + """\ def f(): a_var = 1 # a_var - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent("""\ + dedent( + """\ def f(): new_var = 1 # a_var - """), + """ + ), mod1.read(), ) def test_not_renaming_all_text_occurrences_in_strings_and_comments(self): - code = dedent("""\ + code = dedent( + """\ a_var = 1 # a_vard _a_var - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 # a_vard _a_var - """), + """ + ), mod1.read(), ) def test_renaming_occurrences_in_overwritten_scopes(self): refactored = self._local_rename( - dedent("""\ + dedent( + """\ a_var = 20 def f(): print(a_var) def f(): print(a_var) - """), + """ + ), 2, "new_var", ) self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 20 def f(): print(new_var) def f(): print(new_var) - """), + """ + ), refactored, ) def test_renaming_occurrences_in_overwritten_scopes2(self): - code = dedent("""\ + code = dedent( + """\ def f(): a_var = 1 print(a_var) def f(): a_var = 1 print(a_var) - """) + """ + ) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual(code.replace("a_var", "new_var", 2), refactored) @testutils.only_for_versions_higher("3.5") def test_renaming_in_generalized_dict_unpacking(self): - code = dedent("""\ + code = dedent( + """\ a_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in a_var: print("ya") - """) + """ + ) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") - expected = dedent("""\ + expected = dedent( + """\ new_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in new_var: print("ya") - """) + """ + ) self.assertEqual(expected, refactored) def test_dos_line_ending_and_renaming(self): @@ -1411,30 +1689,38 @@ def test_resources_parameter(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent("""\ + dedent( + """\ def f(): pass - """) + """ + ) ) mod2.write( - dedent("""\ + dedent( + """\ import mod1 mod1.f() - """) + """ + ) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod1]) self.assertEqual( - dedent("""\ + dedent( + """\ def g(): pass - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 mod1.f() - """), + """ + ), mod2.read(), ) @@ -1442,64 +1728,80 @@ def test_resources_parameter_not_changing_defining_module(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent("""\ + dedent( + """\ def f(): pass - """) + """ + ) ) mod2.write( - dedent("""\ + dedent( + """\ import mod1 mod1.f() - """) + """ + ) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod2]) self.assertEqual( - dedent("""\ + dedent( + """\ def f(): pass - """), + """ + ), mod1.read(), ) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 mod1.g() - """), + """ + ), mod2.read(), ) # XXX: with variables should not leak @testutils.only_for("2.5") def xxx_test_with_statement_variables_should_not_leak(self): - code = dedent("""\ + code = dedent( + """\ f = 1 with open("1.txt") as f: print(f) - """) + """ + ) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.rindex("f"), "file") - expected = dedent("""\ + expected = dedent( + """\ f = 1 with open("1.txt") as file: print(file) - """) + """ + ) self.assertEqual(expected, mod1.read()) def test_rename_in_list_comprehension(self): - code = dedent("""\ + code = dedent( + """\ some_var = 1 compr = [some_var for some_var in range(10)] - """) + """ + ) offset = code.index("some_var") refactored = self._local_rename(code, offset, "new_var") - expected = dedent("""\ + expected = dedent( + """\ new_var = 1 compr = [some_var for some_var in range(10)] - """) + """ + ) self.assertEqual(refactored, expected) @@ -1514,91 +1816,107 @@ def tearDown(self): def test_simple_case(self): self.mod.write( - dedent("""\ + dedent( + """\ a_var = 1 print(a_var) - """) + """ + ) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().index("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent("""\ + dedent( + """\ new_var = 1 print(new_var) - """), + """ + ), self.mod.read(), ) def test_only_performing_inside_scopes(self): self.mod.write( - dedent("""\ + dedent( + """\ a_var = 1 new_var = 2 def f(): print(a_var) - """) + """ + ) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent("""\ + dedent( + """\ a_var = 1 new_var = 2 def f(): print(new_var) - """), + """ + ), self.mod.read(), ) def test_only_performing_on_calls(self): self.mod.write( - dedent("""\ + dedent( + """\ def f1(): pass def f2(): pass g = f1 a = f1() - """) + """ + ) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("f1") ) changer.get_changes("f2", only_calls=True).do() self.assertEqual( - dedent("""\ + dedent( + """\ def f1(): pass def f2(): pass g = f1 a = f2() - """), + """ + ), self.mod.read(), ) def test_only_performing_on_reads(self): self.mod.write( - dedent("""\ + dedent( + """\ a = 1 b = 2 print(a) - """) + """ + ) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a") ) changer.get_changes("b", writes=False).do() self.assertEqual( - dedent("""\ + dedent( + """\ a = 1 b = 2 print(b) - """), + """ + ), self.mod.read(), ) @@ -1622,7 +1940,8 @@ def _rename(self, resource, offset, new_name, **kwds): def test_performing_rename_on_parameters(self): self.mod1.write("def f(arg):\n arg.run()\n") self.mod2.write( - dedent("""\ + dedent( + """\ import mod1 @@ -1634,13 +1953,15 @@ def run(self): pass mod1.f(A()) mod1.f(B()) - """) + """ + ) ) self.pycore.analyze_module(self.mod2) self._rename(self.mod1, self.mod1.read().index("run"), "newrun") self.assertEqual("def f(arg):\n arg.newrun()\n", self.mod1.read()) self.assertEqual( - dedent("""\ + dedent( + """\ import mod1 @@ -1652,6 +1973,7 @@ def newrun(self): pass mod1.f(A()) mod1.f(B()) - """), + """ + ), self.mod2.read(), ) From c357dcc940b5d7a8540bc6e373b242a6aa739d79 Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 8 Oct 2021 10:55:07 +0200 Subject: [PATCH 14/20] Revert "black renametest" This reverts commit fb05b152ba50ec7051852f18ff9e85371f1f93ee. --- ropetest/refactor/renametest.py | 880 +++++++++++--------------------- 1 file changed, 294 insertions(+), 586 deletions(-) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index e26e79c88..c4e5ab660 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -41,170 +41,138 @@ def test_simple_global_variable_renaming(self): def test_variable_renaming_only_in_its_scope(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 20 def a_func(): a_var = 10 - """ - ), + """), 32, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ a_var = 20 def a_func(): new_var = 10 - """ - ), + """), refactored, ) def test_not_renaming_dot_name(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ replace = True 'aaa'.replace('a', 'b') - """ - ), + """), 1, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = True 'aaa'.replace('a', 'b') - """ - ), + """), refactored, ) def test_renaming_multiple_names_in_the_same_line(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 10 a_var = 10 + a_var / 2 - """ - ), + """), 2, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 10 new_var = 10 + new_var / 2 - """ - ), + """), refactored, ) def test_renaming_names_when_getting_some_attribute(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 'a b c' a_var.split('\\n') - """ - ), + """), 2, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 'a b c' new_var.split('\\n') - """ - ), + """), refactored, ) def test_renaming_names_when_getting_some_attribute2(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 'a b c' a_var.split('\\n') - """ - ), + """), 20, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 'a b c' new_var.split('\\n') - """ - ), + """), refactored, ) def test_renaming_function_parameters1(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ def f(a_param): print(a_param) - """ - ), + """), 8, "new_param", ) self.assertEqual( - dedent( - """\ + dedent("""\ def f(new_param): print(new_param) - """ - ), + """), refactored, ) def test_renaming_function_parameters2(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ def f(a_param): print(a_param) - """ - ), + """), 30, "new_param", ) self.assertEqual( - dedent( - """\ + dedent("""\ def f(new_param): print(new_param) - """ - ), + """), refactored, ) def test_renaming_occurrences_inside_functions(self): - code = dedent( - """\ + code = dedent("""\ def a_func(p1): a = p1 a_func(1) - """ - ) + """) refactored = self._local_rename(code, code.index("p1") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): a = new_param a_func(1) - """ - ), + """), refactored, ) @@ -240,12 +208,10 @@ def test_renaming_comprehension_loop_variables_scope(self): ) refactored = self._local_rename(code, code.index("b_var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ [new_var for new_var, c_var in d_var if new_var == c_var] b_var = 10 - """ - ), + """), refactored, ) @@ -269,81 +235,65 @@ def test_renaming_inline_assignment(self): ) def test_renaming_arguments_for_normal_args_changing_calls(self): - code = dedent( - """\ + code = dedent("""\ def a_func(p1=None, p2=None): pass a_func(p2=1) - """ - ) + """) refactored = self._local_rename(code, code.index("p2") + 1, "p3") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(p1=None, p3=None): pass a_func(p3=1) - """ - ), + """), refactored, ) def test_renaming_function_parameters_of_class_init(self): - code = dedent( - """\ + code = dedent("""\ class A(object): def __init__(self, a_param): pass a_var = A(a_param=1) - """ - ) + """) refactored = self._local_rename(code, code.index("a_param") + 1, "new_param") - expected = dedent( - """\ + expected = dedent("""\ class A(object): def __init__(self, new_param): pass a_var = A(new_param=1) - """ - ) + """) self.assertEqual(expected, refactored) def test_rename_functions_parameters_and_occurences_in_other_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent( - """\ + dedent("""\ def a_func(a_param): print(a_param) - """ - ) + """) ) mod2.write( - dedent( - """\ + dedent("""\ from mod1 import a_func a_func(a_param=10) - """ - ) + """) ) self._rename(mod1, mod1.read().index("a_param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ from mod1 import a_func a_func(new_param=10) - """ - ), + """), mod2.read(), ) @@ -393,112 +343,91 @@ def test_not_renaming_string_contents_in_f_string(self): "a_var = 20\na_string=f'{\"a_var\"}'\n", 2, "new_var" ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 a_string=f'{"a_var"}' - """ - ), + """), refactored, ) def test_not_renaming_string_contents(self): refactored = self._local_rename("a_var = 20\na_string='a_var'\n", 2, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 a_string='a_var' - """ - ), + """), refactored, ) def test_not_renaming_comment_contents(self): refactored = self._local_rename("a_var = 20\n# a_var\n", 2, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 # a_var - """ - ), + """), refactored, ) def test_renaming_all_occurrences_in_containing_scope(self): - code = dedent( - """\ + code = dedent("""\ if True: a_var = 1 else: a_var = 20 - """ - ) + """) refactored = self._local_rename(code, 16, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ if True: new_var = 1 else: new_var = 20 - """ - ), + """), refactored, ) def test_renaming_a_variable_with_arguement_name(self): - code = dedent( - """\ + code = dedent("""\ a_var = 10 def a_func(a_var): print(a_var) - """ - ) + """) refactored = self._local_rename(code, 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 10 def a_func(a_var): print(a_var) - """ - ), + """), refactored, ) def test_renaming_an_arguement_with_variable_name(self): - code = dedent( - """\ + code = dedent("""\ a_var = 10 def a_func(a_var): print(a_var) - """ - ) + """) refactored = self._local_rename(code, len(code) - 3, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ a_var = 10 def a_func(new_var): print(new_var) - """ - ), + """), refactored, ) def test_renaming_function_with_local_variable_name(self): - code = dedent( - """\ + code = dedent("""\ def a_func(): a_func=20 - a_func()""" - ) + a_func()""") refactored = self._local_rename(code, len(code) - 3, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): a_func=20 new_func()""" @@ -507,37 +436,30 @@ def new_func(): ) def test_renaming_functions(self): - code = dedent( - """\ + code = dedent("""\ def a_func(): pass a_func() - """ - ) + """) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), refactored, ) @testutils.only_for("3.5") def test_renaming_async_function(self): - code = dedent( - """\ + code = dedent("""\ async def a_func(): pass - a_func()""" - ) + a_func()""") refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ async def new_func(): pass new_func()""" @@ -547,17 +469,14 @@ async def new_func(): @testutils.only_for("3.5") def test_renaming_await(self): - code = dedent( - """\ + code = dedent("""\ async def b_func(): pass async def a_func(): - await b_func()""" - ) + await b_func()""") refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ async def new_func(): pass async def a_func(): @@ -569,176 +488,142 @@ async def a_func(): def test_renaming_functions_across_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.a_func() - """ - ) + """) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.new_func() - """ - ), + """), mod2.read(), ) def test_renaming_functions_across_modules_from_import(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ from mod1 import a_func a_func() - """ - ) + """) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ from mod1 import new_func new_func() - """ - ), + """), mod2.read(), ) def test_renaming_functions_from_another_module(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.a_func() - """ - ) + """) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.new_func() - """ - ), + """), mod2.read(), ) def test_applying_all_changes_together(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ import mod2 mod2.a_func() - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( - dedent( - """\ + dedent("""\ import mod2 mod2.new_func() - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ def new_func(): pass new_func() - """ - ), + """), mod2.read(), ) def test_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -751,21 +636,17 @@ def a_func(): def test_renaming_modules_aliased(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 as m m.a_func() - """ - ) + """) ) self._rename(mod1, None, "newmod") self.assertTrue( @@ -777,12 +658,10 @@ def test_renaming_packages(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2", pkg) mod2.write("from pkg.mod1 import a_func\n") @@ -794,67 +673,54 @@ def a_func(): def test_module_dependencies(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ class AClass(object): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() - """ - ) + """) ) self.project.get_pymodule(mod2).get_attributes()["mod1"] mod1.write( - dedent( - """\ + dedent("""\ def AClass(): return 0 - """ - ) + """) ) self._rename(mod2, len(mod2.read()) - 3, "a_func") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(): return 0 - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.a_func() - """ - ), + """), mod2.read(), ) def test_renaming_class_attributes(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): self.an_attr = 10 - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() another_var = a_var.an_attr""" @@ -863,41 +729,35 @@ def __init__(self): self._rename(mod1, mod1.read().index("an_attr"), "attr") self.assertEqual( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): self.attr = 10 - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() another_var = a_var.attr""" ), - mod2.read(), + mod2.read() ) def test_renaming_class_attributes2(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): an_attr = 10 self.an_attr = 10 - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() another_var = a_var.an_attr""" @@ -906,19 +766,16 @@ def __init__(self): self._rename(mod1, mod1.read().rindex("an_attr"), "attr") self.assertEqual( - dedent( - """\ + dedent("""\ class AClass(object): def __init__(self): an_attr = 10 self.attr = 10 - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 a_var = mod1.AClass() another_var = a_var.attr""" @@ -929,40 +786,35 @@ def __init__(self): def test_renaming_methods_in_subclasses(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """ - ) + """) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent( - """\ + dedent("""\ class A(object): def new_method(self): pass class B(A): def new_method(self): pass - """ - ), + """), mod.read(), ) def test_renaming_methods_in_sibling_classes(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass @@ -972,16 +824,14 @@ def a_method(self): class C(A): def a_method(self): pass - """ - ) + """) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=True ) self.assertEqual( - dedent( - """\ + dedent("""\ class A(object): def new_method(self): pass @@ -991,76 +841,65 @@ def new_method(self): class C(A): def new_method(self): pass - """ - ), + """), mod.read(), ) def test_not_renaming_methods_in_hierarchies(self): mod = testutils.create_module(self.project, "mod1") mod.write( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass - """ - ) + """) ) self._rename( mod, mod.read().rindex("a_method") + 1, "new_method", in_hierarchy=False ) self.assertEqual( - dedent( - """\ + dedent("""\ class A(object): def a_method(self): pass class B(A): def new_method(self): pass - """ - ), + """), mod.read(), ) def test_undoing_refactorings(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ) + """) ) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.project.history.undo() self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(): pass a_func() - """ - ), + """), mod1.read(), ) def test_undoing_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write( - dedent( - """\ + dedent("""\ def a_func(): pass - """ - ) + """) ) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") @@ -1079,168 +918,135 @@ def test_rename_in_module_renaming_one_letter_names_for_expressions(self): finder, "new_var", pymodule=pymod, replace_primary=True ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 10 - print(1+new_var) - """ - ), + print(1+new_var) + """), refactored, ) def test_renaming_for_loop_variable(self): - code = dedent( - """\ + code = dedent("""\ for var in range(10): print(var) - """ - ) + """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ for new_var in range(10): print(new_var) - """ - ), + """), refactored, ) @testutils.only_for("3.5") def test_renaming_async_for_loop_variable(self): - code = dedent( - """\ + code = dedent("""\ async def func(): async for var in range(10): print(var) - """ - ) + """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ async def func(): async for new_var in range(10): print(new_var) - """ - ), + """), refactored, ) @testutils.only_for("3.5") def test_renaming_async_with_context_manager(self): - code = dedent( - """\ + code = dedent("""\ def a_cm(): pass async def a_func(): - async with a_cm() as x: pass""" - ) + async with a_cm() as x: pass""") refactored = self._local_rename(code, code.find("a_cm") + 1, "another_cm") - expected = dedent( - """\ + expected = dedent("""\ def another_cm(): pass async def a_func(): - async with another_cm() as x: pass""" - ) + async with another_cm() as x: pass""") self.assertEqual(refactored, expected) @testutils.only_for("3.5") def test_renaming_async_with_as_variable(self): - code = dedent( - """\ + code = dedent("""\ async def func(): async with a_func() as var: print(var) - """ - ) + """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ async def func(): async with a_func() as new_var: print(new_var) - """ - ), + """), refactored, ) def test_renaming_parameters(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) a_func(param=hey) - """ - ) + """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) a_func(new_param=hey) - """ - ), + """), refactored, ) def test_renaming_assigned_parameters(self): - code = dedent( - """\ + code = dedent("""\ def f(p): p = p + 1 return p f(p=1) - """ - ) + """) refactored = self._local_rename(code, code.find("p"), "arg") self.assertEqual( - dedent( - """\ + dedent("""\ def f(arg): arg = arg + 1 return arg f(arg=1) - """ - ), + """), refactored, ) def test_renaming_parameters_not_renaming_others(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) param=10 a_func(param) - """ - ) + """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) param=10 a_func(param) - """ - ), + """), refactored, ) def test_renaming_parameters_not_renaming_others2(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) param=10 - a_func(param=param)""" - ) + a_func(param=param)""") refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) param=10 @@ -1250,102 +1056,82 @@ def a_func(new_param): ) def test_renaming_parameters_with_multiple_params(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """ - ) + """) refactored = self._local_rename(code, code.find("param1") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param, param2): print(new_param) a_func(new_param=1, param2=2) - """ - ), + """), refactored, ) def test_renaming_parameters_with_multiple_params2(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param1, param2): print(param1) a_func(param1=1, param2=2) - """ - ) + """) refactored = self._local_rename(code, code.rfind("param2") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(param1, new_param): print(param1) a_func(param1=1, new_param=2) - """ - ), + """), refactored, ) def test_renaming_parameters_on_calls(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) a_func(param = hey) - """ - ) + """) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) a_func(new_param = hey) - """ - ), + """), refactored, ) def test_renaming_parameters_spaces_before_call(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) a_func (param=hey) - """ - ) + """) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) a_func (new_param=hey) - """ - ), + """), refactored, ) def test_renaming_parameter_like_objects_after_keywords(self): - code = dedent( - """\ + code = dedent("""\ def a_func(param): print(param) dict(param=hey) - """ - ) + """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( - dedent( - """\ + dedent("""\ def a_func(new_param): print(new_param) dict(param=hey) - """ - ), + """), refactored, ) @@ -1405,72 +1191,60 @@ def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): self.assertEqual("import newpkg\nmy_pkg = newpkg", mod1.read()) def test_renaming_global_variables(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 def a_func(): global a_var var = a_var - """ - ) + """) refactored = self._local_rename(code, code.index("a_var"), "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 def a_func(): global new_var var = new_var - """ - ), + """), refactored, ) def test_renaming_global_variables2(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 def a_func(): global a_var var = a_var - """ - ) + """) refactored = self._local_rename(code, code.rindex("a_var"), "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 def a_func(): global new_var var = new_var - """ - ), + """), refactored, ) def test_renaming_when_unsure(self): - code = dedent( - """\ + code = dedent("""\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent( - """\ + dedent("""\ class C(object): def new_func(self): pass def f(arg): arg.new_func() - """ - ), + """), mod1.read(), ) @@ -1481,34 +1255,29 @@ def test_renaming_when_unsure_with_confirmation(self): def confirm(occurrence): return False - code = dedent( - """\ + code = dedent("""\ class C(object): def a_func(self): pass def f(arg): arg.a_func() - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=confirm) self.assertEqual( - dedent( - """\ + dedent("""\ class C(object): def new_func(self): pass def f(arg): arg.a_func() - """ - ), + """), mod1.read(), ) def test_renaming_when_unsure_not_renaming_knowns(self): - code = dedent( - """\ + code = dedent("""\ class C1(object): def a_func(self): pass @@ -1519,14 +1288,12 @@ def a_func(self): c1.a_func() c2 = C2() c2.a_func() - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_func"), "new_func", unsure=self._true) self.assertEqual( - dedent( - """\ + dedent("""\ class C1(object): def new_func(self): pass @@ -1537,111 +1304,92 @@ def a_func(self): c1.new_func() c2 = C2() c2.a_func() - """ - ), + """), mod1.read(), ) def test_renaming_in_strings_and_comments(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 # a_var - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 # new_var - """ - ), + """), mod1.read(), ) def test_not_renaming_in_strings_and_comments_where_not_visible(self): - code = dedent( - """\ + code = dedent("""\ def f(): a_var = 1 # a_var - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent( - """\ + dedent("""\ def f(): new_var = 1 # a_var - """ - ), + """), mod1.read(), ) def test_not_renaming_all_text_occurrences_in_strings_and_comments(self): - code = dedent( - """\ + code = dedent("""\ a_var = 1 # a_vard _a_var - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.index("a_var"), "new_var", docs=True) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 # a_vard _a_var - """ - ), + """), mod1.read(), ) def test_renaming_occurrences_in_overwritten_scopes(self): refactored = self._local_rename( - dedent( - """\ + dedent("""\ a_var = 20 def f(): print(a_var) def f(): print(a_var) - """ - ), + """), 2, "new_var", ) self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 20 def f(): print(new_var) def f(): print(new_var) - """ - ), + """), refactored, ) def test_renaming_occurrences_in_overwritten_scopes2(self): - code = dedent( - """\ + code = dedent("""\ def f(): a_var = 1 print(a_var) def f(): a_var = 1 print(a_var) - """ - ) + """) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual(code.replace("a_var", "new_var", 2), refactored) @@ -1689,38 +1437,30 @@ def test_resources_parameter(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent( - """\ + dedent("""\ def f(): pass - """ - ) + """) ) mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.f() - """ - ) + """) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod1]) self.assertEqual( - dedent( - """\ + dedent("""\ def g(): pass - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.f() - """ - ), + """), mod2.read(), ) @@ -1728,63 +1468,51 @@ def test_resources_parameter_not_changing_defining_module(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write( - dedent( - """\ + dedent("""\ def f(): pass - """ - ) + """) ) mod2.write( - dedent( - """\ + dedent("""\ import mod1 mod1.f() - """ - ) + """) ) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod2]) self.assertEqual( - dedent( - """\ + dedent("""\ def f(): pass - """ - ), + """), mod1.read(), ) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 mod1.g() - """ - ), + """), mod2.read(), ) # XXX: with variables should not leak @testutils.only_for("2.5") def xxx_test_with_statement_variables_should_not_leak(self): - code = dedent( - """\ + code = dedent("""\ f = 1 with open("1.txt") as f: print(f) - """ - ) + """) if sys.version_info < (2, 6, 0): code = "from __future__ import with_statement\n" + code mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) self._rename(mod1, code.rindex("f"), "file") - expected = dedent( - """\ + expected = dedent("""\ f = 1 with open("1.txt") as file: print(file) - """ - ) + """) self.assertEqual(expected, mod1.read()) def test_rename_in_list_comprehension(self): @@ -1816,107 +1544,91 @@ def tearDown(self): def test_simple_case(self): self.mod.write( - dedent( - """\ + dedent("""\ a_var = 1 print(a_var) - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().index("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent( - """\ + dedent("""\ new_var = 1 print(new_var) - """ - ), + """), self.mod.read(), ) def test_only_performing_inside_scopes(self): self.mod.write( - dedent( - """\ + dedent("""\ a_var = 1 new_var = 2 def f(): print(a_var) - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a_var") ) changer.get_changes("new_var").do() self.assertEqual( - dedent( - """\ + dedent("""\ a_var = 1 new_var = 2 def f(): print(new_var) - """ - ), + """), self.mod.read(), ) def test_only_performing_on_calls(self): self.mod.write( - dedent( - """\ + dedent("""\ def f1(): pass def f2(): pass g = f1 a = f1() - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("f1") ) changer.get_changes("f2", only_calls=True).do() self.assertEqual( - dedent( - """\ + dedent("""\ def f1(): pass def f2(): pass g = f1 a = f2() - """ - ), + """), self.mod.read(), ) def test_only_performing_on_reads(self): self.mod.write( - dedent( - """\ + dedent("""\ a = 1 b = 2 print(a) - """ - ) + """) ) changer = rename.ChangeOccurrences( self.project, self.mod, self.mod.read().rindex("a") ) changer.get_changes("b", writes=False).do() self.assertEqual( - dedent( - """\ + dedent("""\ a = 1 b = 2 print(b) - """ - ), + """), self.mod.read(), ) @@ -1940,8 +1652,7 @@ def _rename(self, resource, offset, new_name, **kwds): def test_performing_rename_on_parameters(self): self.mod1.write("def f(arg):\n arg.run()\n") self.mod2.write( - dedent( - """\ + dedent("""\ import mod1 @@ -1953,15 +1664,13 @@ def run(self): pass mod1.f(A()) mod1.f(B()) - """ - ) + """) ) self.pycore.analyze_module(self.mod2) self._rename(self.mod1, self.mod1.read().index("run"), "newrun") self.assertEqual("def f(arg):\n arg.newrun()\n", self.mod1.read()) self.assertEqual( - dedent( - """\ + dedent("""\ import mod1 @@ -1973,7 +1682,6 @@ def newrun(self): pass mod1.f(A()) mod1.f(B()) - """ - ), + """), self.mod2.read(), ) From eec43afa92791268ccff5f4acee5c8c71721e251 Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 8 Oct 2021 11:38:27 +0200 Subject: [PATCH 15/20] fixed code formating --- ropetest/refactor/renametest.py | 66 +++++++++++---------------------- 1 file changed, 22 insertions(+), 44 deletions(-) diff --git a/ropetest/refactor/renametest.py b/ropetest/refactor/renametest.py index c4e5ab660..c456d5858 100644 --- a/ropetest/refactor/renametest.py +++ b/ropetest/refactor/renametest.py @@ -200,12 +200,10 @@ def test_renaming_generator_comprehension_loop_variables(self): ) def test_renaming_comprehension_loop_variables_scope(self): - code = dedent( - """\ + code = dedent("""\ [b_var for b_var, c_var in d_var if b_var == c_var] b_var = 10 - """ - ) + """) refactored = self._local_rename(code, code.index("b_var") + 1, "new_var") self.assertEqual( dedent("""\ @@ -217,20 +215,16 @@ def test_renaming_comprehension_loop_variables_scope(self): @testutils.only_for_versions_higher("3.8") def test_renaming_inline_assignment(self): - code = dedent( - """\ + code = dedent("""\ while a_var := next(foo): print(a_var) - """ - ) + """) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual( - dedent( - """\ + dedent("""\ while new_var := next(foo): print(new_var) - """ - ), + """), refactored, ) @@ -305,35 +299,27 @@ def test_renaming_with_backslash_continued_names(self): @testutils.only_for("3.6") def test_renaming_occurrence_in_f_string(self): - code = dedent( - """\ + code = dedent("""\ a_var = 20 a_string=f'value: {a_var}' - """ - ) - expected = dedent( - """\ + """) + expected = dedent("""\ new_var = 20 a_string=f'value: {new_var}' - """ - ) + """) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) @testutils.only_for("3.6") def test_renaming_occurrence_in_nested_f_string(self): - code = dedent( - """\ + code = dedent("""\ a_var = 20 a_string=f'{f"{a_var}"}' - """ - ) - expected = dedent( - """\ + """) + expected = dedent("""\ new_var = 20 a_string=f'{f"{new_var}"}' - """ - ) + """) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) @@ -1395,25 +1381,21 @@ def f(): @testutils.only_for_versions_higher("3.5") def test_renaming_in_generalized_dict_unpacking(self): - code = dedent( - """\ + code = dedent("""\ a_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in a_var: print("ya") - """ - ) + """) mod1 = testutils.create_module(self.project, "mod1") mod1.write(code) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") - expected = dedent( - """\ + expected = dedent("""\ new_var = {**{'stuff': 'can'}, **{'stuff': 'crayon'}} if "stuff" in new_var: print("ya") - """ - ) + """) self.assertEqual(expected, refactored) def test_dos_line_ending_and_renaming(self): @@ -1516,20 +1498,16 @@ def xxx_test_with_statement_variables_should_not_leak(self): self.assertEqual(expected, mod1.read()) def test_rename_in_list_comprehension(self): - code = dedent( - """\ + code = dedent("""\ some_var = 1 compr = [some_var for some_var in range(10)] - """ - ) + """) offset = code.index("some_var") refactored = self._local_rename(code, offset, "new_var") - expected = dedent( - """\ + expected = dedent("""\ new_var = 1 compr = [some_var for some_var in range(10)] - """ - ) + """) self.assertEqual(refactored, expected) From 016b8d7ef727d475e5189a68079b8ab0c045088c Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 8 Oct 2021 11:41:57 +0200 Subject: [PATCH 16/20] fixed code formating --- ropetest/pyscopestest.py | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/ropetest/pyscopestest.py b/ropetest/pyscopestest.py index 52434660f..09f6da39c 100644 --- a/ropetest/pyscopestest.py +++ b/ropetest/pyscopestest.py @@ -429,14 +429,13 @@ def test_get_inner_scope_for_nested_list_comprhension(self): def test_get_scope_region(self): scope = libutils.get_string_scope( self.project, - dedent( - """ + dedent(""" def func1(ala): pass def func2(o): - pass""" - ), + pass + """), ) self.assertEqual(scope.get_region(), (0, 47)) @@ -446,14 +445,13 @@ def func2(o): def test_only_get_inner_scope_region(self): scope = libutils.get_string_scope( self.project, - dedent( - """ + dedent(""" def func1(ala): pass def func2(o): - pass""" - ), + pass + """), ) self.assertEqual(scope.get_scopes()[1].get_region(), (26, 47)) From 4c00511e1ff34570743a0632576a257c637a3b44 Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 8 Oct 2021 11:42:42 +0200 Subject: [PATCH 17/20] fixed code formating --- ropetest/codeanalyzetest.py | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/ropetest/codeanalyzetest.py b/ropetest/codeanalyzetest.py index ff1e73e23..a42642db0 100644 --- a/ropetest/codeanalyzetest.py +++ b/ropetest/codeanalyzetest.py @@ -634,8 +634,7 @@ def test_generating_line_starts_and_unmatched_deindents(self): self.assertEqual([4, 5], list(line_finder.generate_starts(4))) def test_false_triple_quoted_string(self): - code = dedent( - """\ + code = dedent("""\ def foo(): a = 0 p = 'foo''' @@ -643,8 +642,7 @@ def foo(): def bar(): a = 1 a += 1 - """ - ) + """) line_finder = self._logical_finder(code) self.assertEqual([1, 2, 3, 5, 6, 7], list(line_finder.generate_starts())) self.assertEqual((3, 3), line_finder.logical_line_in(3)) From 8657beb202df8e37f35297eeb65101777490bdd2 Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 8 Oct 2021 11:51:05 +0200 Subject: [PATCH 18/20] fixed code formating --- ropetest/pyscopestest.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/ropetest/pyscopestest.py b/ropetest/pyscopestest.py index 09f6da39c..0f1e0c3d3 100644 --- a/ropetest/pyscopestest.py +++ b/ropetest/pyscopestest.py @@ -334,7 +334,11 @@ def test_get_scope_for_offset_for_scope_with_indent(self): def test_get_scope_for_offset_for_function_scope_and_async_with_statement(self): scope = libutils.get_string_scope( self.project, - "async def func():\n async with a_func() as var:\n print(var)\n", + dedent("""\ + async def func(): + async with a_func() as var: + print(var) + """) ) inner_scope = scope.get_scopes()[0] self.assertEqual(inner_scope, scope.get_inner_scope_for_offset(27)) @@ -438,7 +442,7 @@ def func2(o): """), ) - self.assertEqual(scope.get_region(), (0, 47)) + self.assertEqual(scope.get_region(), (0, 48)) self.assertEqual(scope.get_scopes()[0].get_region(), (1, 24)) self.assertEqual(scope.get_scopes()[1].get_region(), (26, 47)) From 5ebec85ff59c5f3b01d827d793004f0ebee2e61d Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 8 Oct 2021 11:54:23 +0200 Subject: [PATCH 19/20] fixed code formating --- ropetest/pyscopestest.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/ropetest/pyscopestest.py b/ropetest/pyscopestest.py index 52434660f..9c21f66b3 100644 --- a/ropetest/pyscopestest.py +++ b/ropetest/pyscopestest.py @@ -334,7 +334,11 @@ def test_get_scope_for_offset_for_scope_with_indent(self): def test_get_scope_for_offset_for_function_scope_and_async_with_statement(self): scope = libutils.get_string_scope( self.project, - "async def func():\n async with a_func() as var:\n print(var)\n", + dedent("""\ + async def func(): + async with a_func() as var: + print(var) + """) ) inner_scope = scope.get_scopes()[0] self.assertEqual(inner_scope, scope.get_inner_scope_for_offset(27)) From dfc1e5548024dae02526c099274aca0c4c51a92a Mon Sep 17 00:00:00 2001 From: climbus Date: Fri, 8 Oct 2021 12:01:01 +0200 Subject: [PATCH 20/20] changed calculations method name --- rope/base/pyscopes.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rope/base/pyscopes.py b/rope/base/pyscopes.py index 2d2a5d93d..c6050d19b 100644 --- a/rope/base/pyscopes.py +++ b/rope/base/pyscopes.py @@ -108,7 +108,7 @@ def get_region(self): return region def _calculate_scope_regions_for_module(self): - self._get_global_scope().calculate_scope_regions() + self._get_global_scope()._calculate_scope_regions() def in_region(self, offset): """Checks if offset is in scope region""" @@ -137,7 +137,7 @@ def get_name(self, name): raise exceptions.NameNotFoundError("name %s not found" % name) @utils.saveit - def calculate_scope_regions(self): + def _calculate_scope_regions(self): source = self._get_source() patchedast.patch_ast(self.pyobject.get_ast(), source)