import sys import unittest from textwrap import dedent import rope.base.codeanalyze import rope.refactor.occurrences from rope.refactor import rename from rope.refactor.rename import Rename from ropetest import testutils class RenameRefactoringTest(unittest.TestCase): def setUp(self): super().setUp() self.project = testutils.sample_project() def tearDown(self): testutils.remove_project(self.project) super().tearDown() def _local_rename(self, source_code, offset, new_name): testmod = testutils.create_module(self.project, "testmod") testmod.write(source_code) changes = Rename(self.project, testmod, offset).get_changes( new_name, resources=[testmod] ) self.project.do(changes) return testmod.read() def _rename(self, resource, offset, new_name, **kwds): changes = Rename(self.project, resource, offset).get_changes(new_name, **kwds) self.project.do(changes) def test_local_variable_but_not_parameter(self): code = dedent("""\ a = 10 foo = dict(a=a) """) refactored = self._local_rename(code, 1, "new_a") self.assertEqual( dedent("""\ new_a = 10 foo = dict(a=new_a) """), refactored, ) def test_simple_global_variable_renaming(self): refactored = self._local_rename("a_var = 20\n", 2, "new_var") self.assertEqual("new_var = 20\n", refactored) def test_variable_renaming_only_in_its_scope(self): refactored = self._local_rename( dedent("""\ a_var = 20 def a_func(): a_var = 10 """), 32, "new_var", ) self.assertEqual( dedent("""\ a_var = 20 def a_func(): new_var = 10 """), refactored, ) def test_not_renaming_dot_name(self): refactored = self._local_rename( dedent("""\ replace = True 'aaa'.replace('a', 'b') """), 1, "new_var", ) self.assertEqual( dedent("""\ new_var = True 'aaa'.replace('a', 'b') """), refactored, ) def test_renaming_multiple_names_in_the_same_line(self): refactored = self._local_rename( dedent("""\ a_var = 10 a_var = 10 + a_var / 2 """), 2, "new_var", ) self.assertEqual( 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("""\ a_var = 'a b c' a_var.split('\\n') """), 2, "new_var", ) self.assertEqual( 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("""\ a_var = 'a b c' a_var.split('\\n') """), 20, "new_var", ) self.assertEqual( dedent("""\ new_var = 'a b c' new_var.split('\\n') """), refactored, ) def test_renaming_function_parameters1(self): refactored = self._local_rename( dedent("""\ def f(a_param): print(a_param) """), 8, "new_param", ) self.assertEqual( dedent("""\ def f(new_param): print(new_param) """), refactored, ) def test_renaming_function_parameters2(self): refactored = self._local_rename( dedent("""\ def f(a_param): print(a_param) """), 30, "new_param", ) self.assertEqual( dedent("""\ def f(new_param): print(new_param) """), refactored, ) def test_renaming_occurrences_inside_functions(self): 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("""\ def a_func(new_param): a = new_param a_func(1) """), refactored, ) def test_renaming_comprehension_loop_variables(self): code = "[b_var for b_var, c_var in d_var if b_var == c_var]" 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]", refactored ) def test_renaming_list_comprehension_loop_variables_in_assignment(self): code = "a_var = [b_var for b_var, c_var in d_var if b_var == c_var]" refactored = self._local_rename(code, code.index("b_var") + 1, "new_var") self.assertEqual( "a_var = [new_var for new_var, c_var in d_var if new_var == c_var]", refactored, ) def test_renaming_generator_comprehension_loop_variables(self): code = "a_var = (b_var for b_var, c_var in d_var if b_var == c_var)" refactored = self._local_rename(code, code.index("b_var") + 1, "new_var") self.assertEqual( "a_var = (new_var for new_var, c_var in d_var if new_var == c_var)", refactored, ) def test_renaming_comprehension_loop_variables_scope(self): 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("""\ [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("""\ while a_var := next(foo): print(a_var) """) refactored = self._local_rename(code, code.index("a_var") + 1, "new_var") self.assertEqual( dedent("""\ while new_var := next(foo): print(new_var) """), refactored, ) def test_renaming_arguments_for_normal_args_changing_calls(self): 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("""\ def a_func(p1=None, p3=None): pass a_func(p3=1) """), refactored, ) def test_renaming_function_parameters_of_class_init(self): 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("""\ 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_occurrences_in_other_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write(dedent("""\ def a_func(a_param): print(a_param) """)) mod2.write(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("""\ def a_func(new_param): print(new_param) """), mod1.read(), ) self.assertEqual( dedent("""\ from mod1 import a_func a_func(new_param=10) """), mod2.read(), ) def test_renaming_with_backslash_continued_names(self): refactored = self._local_rename( "replace = True\n'ali'.\\\nreplace\n", 2, "is_replace" ) self.assertEqual("is_replace = True\n'ali'.\\\nreplace\n", refactored) def test_renaming_occurrence_in_f_string(self): code = dedent("""\ a_var = 20 a_string=f'value: {a_var}' """) expected = dedent("""\ new_var = 20 a_string=f'value: {new_var}' """) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) def test_renaming_occurrence_in_nested_f_string(self): code = dedent("""\ a_var = 20 a_string=f'{f"{a_var}"}' """) expected = dedent("""\ new_var = 20 a_string=f'{f"{new_var}"}' """) refactored = self._local_rename(code, 2, "new_var") self.assertEqual(expected, refactored) def test_not_renaming_string_contents_in_f_string(self): refactored = self._local_rename( "a_var = 20\na_string=f'{\"a_var\"}'\n", 2, "new_var" ) self.assertEqual( 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("""\ 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("""\ new_var = 20 # a_var """), refactored, ) def test_renaming_all_occurrences_in_containing_scope(self): code = dedent("""\ if True: a_var = 1 else: a_var = 20 """) refactored = self._local_rename(code, 16, "new_var") self.assertEqual( dedent("""\ if True: new_var = 1 else: new_var = 20 """), refactored, ) def test_renaming_a_variable_with_arguement_name(self): code = dedent("""\ a_var = 10 def a_func(a_var): print(a_var) """) refactored = self._local_rename(code, 1, "new_var") self.assertEqual( dedent("""\ new_var = 10 def a_func(a_var): print(a_var) """), refactored, ) def test_renaming_an_arguement_with_variable_name(self): 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("""\ a_var = 10 def a_func(new_var): print(new_var) """), refactored, ) def test_renaming_function_with_local_variable_name(self): code = dedent("""\ def a_func(): a_func=20 a_func()""") refactored = self._local_rename(code, len(code) - 3, "new_func") self.assertEqual( dedent("""\ def new_func(): a_func=20 new_func()"""), refactored, ) def test_renaming_functions(self): code = dedent("""\ def a_func(): pass a_func() """) refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( dedent("""\ def new_func(): pass new_func() """), refactored, ) def test_renaming_async_function(self): code = dedent("""\ async def a_func(): pass a_func()""") refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( dedent("""\ async def new_func(): pass new_func()"""), refactored, ) def test_renaming_await(self): code = dedent("""\ async def b_func(): pass async def a_func(): await b_func()""") refactored = self._local_rename(code, len(code) - 5, "new_func") self.assertEqual( dedent("""\ async def new_func(): pass async def a_func(): await new_func()"""), refactored, ) def test_renaming_functions_across_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write(dedent("""\ def a_func(): pass a_func() """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ import mod1 mod1.a_func() """)) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( dedent("""\ def new_func(): pass new_func() """), mod1.read(), ) self.assertEqual( 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("""\ def a_func(): pass a_func() """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ from mod1 import a_func a_func() """)) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.assertEqual( dedent("""\ def new_func(): pass new_func() """), mod1.read(), ) self.assertEqual( 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("""\ def a_func(): pass a_func() """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ import mod1 mod1.a_func() """)) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( dedent("""\ def new_func(): pass new_func() """), mod1.read(), ) self.assertEqual( 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("""\ import mod2 mod2.a_func() """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ def a_func(): pass a_func() """)) self._rename(mod2, len(mod2.read()) - 5, "new_func") self.assertEqual( dedent("""\ import mod2 mod2.new_func() """), mod1.read(), ) self.assertEqual( dedent("""\ def new_func(): pass new_func() """), mod2.read(), ) def test_renaming_modules(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write(dedent("""\ def a_func(): pass """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") self._rename(mod2, mod2.read().index("mod1") + 1, "newmod") self.assertTrue( not mod1.exists() and self.project.find_module("newmod") is not None ) self.assertEqual("from newmod import a_func\n", mod2.read()) def test_renaming_modules_aliased(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write(dedent("""\ def a_func(): pass """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ import mod1 as m m.a_func() """)) self._rename(mod1, None, "newmod") self.assertTrue( not mod1.exists() and self.project.find_module("newmod") is not None ) self.assertEqual("import newmod as m\nm.a_func()\n", mod2.read()) def test_renaming_packages(self): pkg = testutils.create_package(self.project, "pkg") mod1 = testutils.create_module(self.project, "mod1", pkg) mod1.write(dedent("""\ def a_func(): pass """)) mod2 = testutils.create_module(self.project, "mod2", pkg) mod2.write("from pkg.mod1 import a_func\n") self._rename(mod2, 6, "newpkg") self.assertTrue(self.project.find_module("newpkg.mod1") is not None) new_mod2 = self.project.find_module("newpkg.mod2") self.assertEqual("from newpkg.mod1 import a_func\n", new_mod2.read()) def test_module_dependencies(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write(dedent("""\ class AClass(object): pass """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ import mod1 a_var = mod1.AClass() """)) self.project.get_pymodule(mod2).get_attributes()["mod1"] mod1.write(dedent("""\ def AClass(): return 0 """)) self._rename(mod2, len(mod2.read()) - 3, "a_func") self.assertEqual( dedent("""\ def a_func(): return 0 """), mod1.read(), ) self.assertEqual( 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("""\ class AClass(object): def __init__(self): self.an_attr = 10 """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ import mod1 a_var = mod1.AClass() another_var = a_var.an_attr""")) self._rename(mod1, mod1.read().index("an_attr"), "attr") self.assertEqual( dedent("""\ class AClass(object): def __init__(self): self.attr = 10 """), mod1.read(), ) self.assertEqual( dedent("""\ import mod1 a_var = mod1.AClass() another_var = a_var.attr"""), mod2.read(), ) def test_renaming_class_attributes2(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write(dedent("""\ class AClass(object): def __init__(self): an_attr = 10 self.an_attr = 10 """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ import mod1 a_var = mod1.AClass() another_var = a_var.an_attr""")) self._rename(mod1, mod1.read().rindex("an_attr"), "attr") self.assertEqual( dedent("""\ class AClass(object): def __init__(self): an_attr = 10 self.attr = 10 """), mod1.read(), ) self.assertEqual( dedent("""\ import mod1 a_var = mod1.AClass() another_var = a_var.attr"""), mod2.read(), ) def test_renaming_methods_in_subclasses(self): mod = testutils.create_module(self.project, "mod1") mod.write(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("""\ 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("""\ class A(object): def a_method(self): pass class B(A): def a_method(self): pass 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("""\ class A(object): def new_method(self): pass class B(A): def new_method(self): pass 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("""\ 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("""\ 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("""\ def a_func(): pass a_func() """)) self._rename(mod1, len(mod1.read()) - 5, "new_func") self.project.history.undo() self.assertEqual( 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("""\ def a_func(): pass """)) mod2 = testutils.create_module(self.project, "mod2") mod2.write("from mod1 import a_func\n") self._rename(mod2, 6, "newmod") self.project.history.undo() self.assertEqual("mod1.py", mod1.path) self.assertEqual("from mod1 import a_func\n", mod2.read()) def test_rename_in_module_renaming_one_letter_names_for_expressions(self): mod1 = testutils.create_module(self.project, "mod1") mod1.write("a = 10\nprint(1+a)\n") pymod = self.project.get_module("mod1") old_pyname = pymod["a"] finder = rope.refactor.occurrences.create_finder(self.project, "a", old_pyname) refactored = rename.rename_in_module( finder, "new_var", pymodule=pymod, replace_primary=True ) self.assertEqual( dedent("""\ new_var = 10 print(1+new_var) """), refactored, ) def test_renaming_for_loop_variable(self): code = dedent("""\ for var in range(10): print(var) """) refactored = self._local_rename(code, code.find("var") + 1, "new_var") self.assertEqual( dedent("""\ for new_var in range(10): print(new_var) """), refactored, ) def test_renaming_async_for_loop_variable(self): 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("""\ async def func(): async for new_var in range(10): print(new_var) """), refactored, ) def test_renaming_async_with_context_manager(self): code = dedent("""\ def a_cm(): pass async def a_func(): async with a_cm() as x: pass""") refactored = self._local_rename(code, code.find("a_cm") + 1, "another_cm") expected = dedent("""\ def another_cm(): pass async def a_func(): async with another_cm() as x: pass""") self.assertEqual(refactored, expected) def test_renaming_async_with_as_variable(self): 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("""\ async def func(): async with a_func() as new_var: print(new_var) """), refactored, ) def test_renaming_parameters(self): 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("""\ def a_func(new_param): print(new_param) a_func(new_param=hey) """), refactored, ) def test_renaming_assigned_parameters(self): 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("""\ def f(arg): arg = arg + 1 return arg f(arg=1) """), refactored, ) def test_renaming_parameters_not_renaming_others(self): 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("""\ def a_func(new_param): print(new_param) param=10 a_func(param) """), refactored, ) def test_renaming_parameters_not_renaming_others2(self): code = dedent("""\ def a_func(param): print(param) param=10 a_func(param=param)""") refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( dedent("""\ def a_func(new_param): print(new_param) param=10 a_func(new_param=param)"""), refactored, ) def test_renaming_parameters_with_multiple_params(self): 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("""\ 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("""\ 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("""\ 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("""\ def a_func(param): print(param) a_func(param = hey) """) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( 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("""\ def a_func(param): print(param) a_func (param=hey) """) refactored = self._local_rename(code, code.rfind("param") + 1, "new_param") self.assertEqual( 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("""\ def a_func(param): print(param) dict(param=hey) """) refactored = self._local_rename(code, code.find("param") + 1, "new_param") self.assertEqual( dedent("""\ def a_func(new_param): print(new_param) dict(param=hey) """), refactored, ) def test_renaming_variables_in_init_dot_pys(self): pkg = testutils.create_package(self.project, "pkg") init_dot_py = pkg.get_child("__init__.py") init_dot_py.write("a_var = 10\n") mod = testutils.create_module(self.project, "mod") mod.write("import pkg\nprint(pkg.a_var)\n") self._rename(mod, mod.read().index("a_var") + 1, "new_var") self.assertEqual("new_var = 10\n", init_dot_py.read()) self.assertEqual("import pkg\nprint(pkg.new_var)\n", mod.read()) def test_renaming_variables_in_init_dot_pys2(self): pkg = testutils.create_package(self.project, "pkg") init_dot_py = pkg.get_child("__init__.py") init_dot_py.write("a_var = 10\n") mod = testutils.create_module(self.project, "mod") mod.write("import pkg\nprint(pkg.a_var)\n") self._rename(init_dot_py, init_dot_py.read().index("a_var") + 1, "new_var") self.assertEqual("new_var = 10\n", init_dot_py.read()) self.assertEqual("import pkg\nprint(pkg.new_var)\n", mod.read()) def test_renaming_variables_in_init_dot_pys3(self): pkg = testutils.create_package(self.project, "pkg") init_dot_py = pkg.get_child("__init__.py") init_dot_py.write("a_var = 10\n") mod = testutils.create_module(self.project, "mod") mod.write("import pkg\nprint(pkg.a_var)\n") self._rename(mod, mod.read().index("a_var") + 1, "new_var") self.assertEqual("new_var = 10\n", init_dot_py.read()) self.assertEqual("import pkg\nprint(pkg.new_var)\n", mod.read()) def test_renaming_resources_using_rename_module_refactoring(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write("a_var = 1") mod2.write("import mod1\nmy_var = mod1.a_var\n") renamer = rename.Rename(self.project, mod1) renamer.get_changes("newmod").do() self.assertEqual("import newmod\nmy_var = newmod.a_var\n", mod2.read()) def test_renam_resources_using_rename_module_refactor_for_packages(self): mod1 = testutils.create_module(self.project, "mod1") pkg = testutils.create_package(self.project, "pkg") mod1.write("import pkg\nmy_pkg = pkg") renamer = rename.Rename(self.project, pkg) renamer.get_changes("newpkg").do() self.assertEqual("import newpkg\nmy_pkg = newpkg", mod1.read()) def test_renam_resources_use_rename_module_refactor_for_init_dot_py(self): mod1 = testutils.create_module(self.project, "mod1") pkg = testutils.create_package(self.project, "pkg") mod1.write("import pkg\nmy_pkg = pkg") renamer = rename.Rename(self.project, pkg.get_child("__init__.py")) renamer.get_changes("newpkg").do() self.assertEqual("import newpkg\nmy_pkg = newpkg", mod1.read()) def test_renaming_global_variables(self): 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("""\ new_var = 1 def a_func(): global new_var var = new_var """), refactored, ) def test_renaming_global_variables2(self): 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("""\ new_var = 1 def a_func(): global new_var var = new_var """), refactored, ) def test_renaming_when_unsure(self): 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("""\ class C(object): def new_func(self): pass def f(arg): arg.new_func() """), mod1.read(), ) def _true(self, *args): return True def test_renaming_when_unsure_with_confirmation(self): def confirm(occurrence): return False 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("""\ 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("""\ class C1(object): def a_func(self): pass class C2(object): def a_func(self): pass c1 = C1() 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("""\ class C1(object): def new_func(self): pass class C2(object): def a_func(self): pass c1 = C1() c1.new_func() c2 = C2() c2.a_func() """), mod1.read(), ) def test_renaming_in_strings_and_comments(self): 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("""\ new_var = 1 # new_var """), mod1.read(), ) def test_not_renaming_in_strings_and_comments_where_not_visible(self): 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("""\ def f(): new_var = 1 # a_var """), mod1.read(), ) def test_not_renaming_all_text_occurrences_in_strings_and_comments(self): 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("""\ new_var = 1 # a_vard _a_var """), mod1.read(), ) def test_renaming_occurrences_in_overwritten_scopes(self): refactored = self._local_rename( dedent("""\ a_var = 20 def f(): print(a_var) def f(): print(a_var) """), 2, "new_var", ) self.assertEqual( 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("""\ 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("""\ 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("""\ 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): code = "\r\na = 1\r\n\r\nprint(2 + a + 2)\r\n" offset = code.replace("\r\n", "\n").rindex("a") refactored = self._local_rename(code, offset, "b") self.assertEqual( "\nb = 1\n\nprint(2 + b + 2)\n", refactored.replace("\r\n", "\n") ) def test_multi_byte_strs_and_renaming(self): s = "{LATIN SMALL LETTER I WITH DIAERESIS}" * 4 code = "# -*- coding: utf-8 -*-\n# " + s + "\na = 1\nprint(2 + a + 2)\n" refactored = self._local_rename(code, code.rindex("a"), "b") self.assertEqual( "# -*- coding: utf-8 -*-\n# " + s + "\nb = 1\nprint(2 + b + 2)\n", refactored, ) def test_resources_parameter(self): mod1 = testutils.create_module(self.project, "mod1") mod2 = testutils.create_module(self.project, "mod2") mod1.write(dedent("""\ def f(): pass """)) mod2.write(dedent("""\ import mod1 mod1.f() """)) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod1]) self.assertEqual( dedent("""\ def g(): pass """), mod1.read(), ) self.assertEqual( dedent("""\ import mod1 mod1.f() """), mod2.read(), ) 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("""\ def f(): pass """)) mod2.write(dedent("""\ import mod1 mod1.f() """)) self._rename(mod1, mod1.read().rindex("f"), "g", resources=[mod2]) self.assertEqual( dedent("""\ def f(): pass """), mod1.read(), ) self.assertEqual( dedent("""\ import mod1 mod1.g() """), mod2.read(), ) # XXX: with variables should not leak def xxx_test_with_statement_variables_should_not_leak(self): 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("""\ f = 1 with open("1.txt") as file: print(file) """) 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) def test_renaming_modules_aliased_with_dots(self): pkg = testutils.create_package(self.project, "json") mod1 = testutils.create_module(self.project, "utils", pkg) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ import json.utils as stdlib_json_utils """)) self._rename(pkg, None, "new_json") self.assertTrue( not mod1.exists() and self.project.find_module("new_json.utils") is not None ) self.assertEqual("import new_json.utils as stdlib_json_utils\n", mod2.read()) def test_renaming_modules_aliased_many_dots(self): pkg = testutils.create_package(self.project, "json") mod1 = testutils.create_module(self.project, "utils", pkg) mod2 = testutils.create_module(self.project, "mod2") mod2.write(dedent("""\ import json.utils.a as stdlib_json_utils """)) self._rename(pkg, None, "new_json") self.assertTrue( not mod1.exists() and self.project.find_module("new_json.utils") is not None ) self.assertEqual("import new_json.utils.a as stdlib_json_utils\n", mod2.read()) class ChangeOccurrencesTest(unittest.TestCase): def setUp(self): self.project = testutils.sample_project() self.mod = testutils.create_module(self.project, "mod") def tearDown(self): testutils.remove_project(self.project) super().tearDown() def test_simple_case(self): self.mod.write(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("""\ new_var = 1 print(new_var) """), self.mod.read(), ) def test_only_performing_inside_scopes(self): self.mod.write(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("""\ 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("""\ 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("""\ def f1(): pass def f2(): pass g = f1 a = f2() """), self.mod.read(), ) def test_only_performing_on_reads(self): self.mod.write(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("""\ a = 1 b = 2 print(b) """), self.mod.read(), ) class ImplicitInterfacesTest(unittest.TestCase): def setUp(self): super().setUp() self.project = testutils.sample_project(validate_objectdb=True) self.pycore = self.project.pycore self.mod1 = testutils.create_module(self.project, "mod1") self.mod2 = testutils.create_module(self.project, "mod2") def tearDown(self): testutils.remove_project(self.project) super().tearDown() def _rename(self, resource, offset, new_name, **kwds): changes = Rename(self.project, resource, offset).get_changes(new_name, **kwds) self.project.do(changes) def test_performing_rename_on_parameters(self): self.mod1.write("def f(arg):\n arg.run()\n") self.mod2.write(dedent("""\ import mod1 class A(object): def run(self): pass class B(object): 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("""\ import mod1 class A(object): def newrun(self): pass class B(object): def newrun(self): pass mod1.f(A()) mod1.f(B()) """), self.mod2.read(), )