Пример #1
0
def pyls_rename(config, workspace, document, position, new_name):
    rope_config = config.settings(document_path=document.path).get('rope', {})
    rope_project = workspace._rope_project_builder(rope_config)

    rename = Rename(rope_project,
                    libutils.path_to_resource(rope_project, document.path),
                    document.offset_at_position(position))

    log.debug("Executing rename of %s to %s",
              document.word_at_position(position), new_name)
    changeset = rename.get_changes(new_name, in_hierarchy=True, docs=True)
    log.debug("Finished rename: %s", changeset.changes)
    return {
        'documentChanges': [{
            'textDocument': {
                'uri':
                uris.uri_with(document.uri,
                              path=os.path.join(workspace.root_path,
                                                change.resource.path)),
            },
            'edits': [{
                'range': {
                    'start': {
                        'line': 0,
                        'character': 0
                    },
                    'end': {
                        'line': sys.maxsize,
                        'character': 0
                    },
                },
                'newText': change.new_contents
            }]
        } for change in changeset.changes]
    }
Пример #2
0
 def rename(self):
     """
     Renames word under cursor.
     """
     editor = api.editor.get_current_editor()
     if editor is None:
         return
     editor.file.save()
     assert isinstance(editor, PyCodeEdit)
     module = libutils.path_to_resource(self._main_project,
                                        editor.file.path)
     self._main_project.validate()
     cursor_position = self._get_real_position(
         editor.textCursor().position())
     try:
         renamer = Rename(self._main_project, module, cursor_position)
     except RopeError:
         return
     if not renamer.get_old_name():
         return
     preview, replacement = DlgRope.rename(self.main_window,
                                           renamer.get_old_name())
     if preview is None and replacement is None:
         return
     multiproj = self._has_multiple_projects()
     other_projects = self._get_other_projects()
     main_project = self._main_project
     self._preview = preview
     api.tasks.start(_('Refactoring: rename'),
                     rename_symbol,
                     self._on_changes_available,
                     args=(main_project, multiproj, other_projects,
                           editor.file.path, cursor_position, replacement),
                     cancellable=True,
                     use_thread=True)
Пример #3
0
def rename_symbol(_, main_project, multiproj, other_projects, file_path,
                  cursor_position, replacement):
    """
    Renames symbol under cusror.
    """
    try:
        main_project.validate()
        module = libutils.path_to_resource(main_project, file_path)
        if multiproj:
            # we need to rename cross project
            crossrename = multiproject.MultiProjectRefactoring(
                Rename, other_projects)
            renamer = crossrename(main_project, module, cursor_position)
            pending_changes = renamer.get_all_changes(replacement, docs=True)
        else:
            renamer = Rename(main_project, module, cursor_position)
            pending_changes = renamer.get_changes(replacement, docs=True)
        return multiproj, pending_changes
    except RopeError as e:
        error = RefactoringError()
        error.exc = str(e)
        error.traceback = traceback.format_exc()
        error.critical = False
        return error
    except Exception as e:
        error = RefactoringError()
        error.exc = str(e)
        error.traceback = traceback.format_exc()
        error.critical = True
        return error
Пример #4
0
 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()
Пример #5
0
def rename():
    with ropemate.context as context:
        if current_identifier == "":
            tooltip("Select an identifier to rename")
            return context.input
        
        offset = caret_position(context.input)
        try:
            rename = Rename(context.project, context.resource, offset)
            
            func_name = get_input(title="New name",default=rename.old_name)
            if func_name is None or func_name == rename.old_name:
                tooltip("Enter a new name!")
                return context.input
            
            changes = rename.get_changes(func_name, in_hierarchy=True)
            # remove the current file from the changeset.
            # we will apply the changes to this file manually,
            # (as the result of the TM Command) to keep TM's undo history in order
            current_file_changes = filter_changes_in_current_file(changes,context.resource)
            result = current_file_changes.new_contents
            # apply changes to all other files
            context.project.do(changes)
        except Exception, e:
            tooltip(e)
            result = context.input
        
        return result
Пример #6
0
 def refactor_rename_at_point(self, offset, new_name, in_hierarchy, docs):
     """Rename the symbol at point."""
     refactor = Rename(self.project, self.resource, offset)
     changes = refactor.get_changes(new_name,
                                    in_hierarchy=in_hierarchy,
                                    docs=docs)
     return translate_changes(changes)
Пример #7
0
 def refactor_rename_at_point(self, offset, new_name, in_hierarchy, docs):
     """Rename the symbol at point."""
     try:
         refactor = Rename(self.project, self.resource, offset)
     except RefactoringError as e:
         raise Fault(str(e), code=400)
     return self._get_changes(refactor, new_name,
                              in_hierarchy=in_hierarchy, docs=docs)
Пример #8
0
def rename(source_string, start, end, new_name):
    if new_name == '':
        new_name = 'renamed_variable'
    project, resource = make_temporary_project_and_resource(source_string)

    renamer = Rename(project, resource, start)
    changes = renamer.get_changes(new_name)

    return get_result(changes, project, resource)
Пример #9
0
 def onRefactor(self):
     renamed = Rename(self.project, self.resource, self.startOffset)
     changes = renamed.get_changes(self._newName, task_handle=self._handle)
     for item in changes.changes:
         if isinstance(item, rope.base.change.ChangeContents):
             self.changes.append(
                 Change(item.resource.real_path, ChangeType.EDIT, item.get_description()))
         else:
             raise Exception('Unknown Change')
Пример #10
0
    def run(self, edit, block=False):
        self.view.run_command("save")
        self.original_loc = self.view.rowcol(self.view.sel()[0].a)
        with ropemate.ropecontext(self.view) as context:
            self.sel = self.view.sel()[0]
            word = self.view.substr(self.view.word(self.sel.b))

            self.rename = Rename(context.project, context.resource, self.sel.b)
            self.view.window().show_input_panel(
                "New name", word, self.new_name_entered, None, None)
Пример #11
0
def rename_all_api_modules():
    print('API modules are renaming (drop redundant "_api" suffix).')
    for api_resource in api_resources.get_folders():
        if api_resource.name.endswith('_api'):
            rename = Rename(project, api_resource)
            new_name = rename.get_old_name().split('_api')[0]

            print('\told: ' + api_resource.name + ' new: ' + new_name)

            changes = rename.get_changes(new_name)
            project.do(changes)
Пример #12
0
def rename_module(project, old_module, new_module):
    try:
        tempdir = tempfile.mkdtemp()
        os.makedirs(os.path.join(tempdir, old_module))
        open(os.path.join(tempdir, old_module, '__init__.py'), 'a').close()
        sys.path.append(tempdir)

        resource = project.find_module(old_module)
        changes = Rename(project, resource).get_changes(new_module)
        changes.do()
    finally:
        shutil.rmtree(tempdir, ignore_errors=True)
Пример #13
0
def main():
    from rope.base.project import Project
    from rope.base import libutils
    from rope.refactor.rename import Rename
    from rope.base.exceptions import RopeError

    path = editor.get_path()
    selection = editor.get_selection()

    if not path or not selection:
        console.hud_alert('Not a Python file', 'error')
        return

    tab.save()

    project = None
    try:
        project = Project(os.path.dirname(path), ropefolder=None)
        resource = libutils.path_to_resource(project, path)
        if not libutils.is_python_file(project, resource):
            console.hud_alert('Not a Python file', 'error')
            return

        renamer = Rename(project, resource, selection[0])
        old_name = renamer.get_old_name()

        if not old_name:
            console.hud_alert('Unable to get identifier name', 'error')
            return

        new_name = _ask_for_new_name(old_name)

        change_set = renamer.get_changes(new_name,
                                         docs=True,
                                         resources=[resource])
        if not change_set:
            console.hud_alert('No changes required')
            return

        if refactoring.ask_if_apply_change_set(change_set):
            refactoring.apply_change_set(change_set, path, selection)
            console.hud_alert('Identifier renamed')

    except RopeError as e:
        console.hud_alert(str(e), 'error')

    except KeyboardInterrupt:
        pass

    finally:
        if project:
            project.close()
Пример #14
0
 def setFileToRename_destinationName(self, wantedResultName: str):
     self.destinationName = wantedResultName
     try:
         self.change = Rename(
             self.proj,
             self.fileToRename
         ).get_changes(wantedResultName)
         # )._rename_module(wantedResultName)
     except FileNotFoundError as err:
         print("\n+++There is no file in given name or path to change its name or path.\n")
         print(err)
     except Exception as err:
         print("\n+++Error while searching file which you wanted to be renamed.\n")
         print(err)
Пример #15
0
def _rename_package(project: Project, old_name: str, new_name: str) -> None:
    """
    Rename a Python package, refactoring relevant imports along the way,
    as well as references in comments.

    Args:
        project: rope.base.Project holding the scope of the refactoring.
        old_name: Old module name. Can be a fully qualified module path,
            e.g. "package.pipelines.pipeline" or "package/pipelines/pipeline",
            relative to the `project` root.
        new_name: New module name. Can't be a fully qualified module path.
    """
    folder = project.get_folder(old_name)
    change = Rename(project, folder).get_changes(new_name, docs=True)
    project.do(change)
Пример #16
0
 def run(self):
     self.error = None
     self.changedFiles = []
     try:
         self.ropeProject.validate()
         rename = Rename(
             self.ropeProject,
             libutils.path_to_resource(self.ropeProject, self.path),
             self.offset)
         changes = rename.get_changes(self.new_name, docs=True)
         self.ropeProject.do(changes)
         changed = changes.get_changed_resources()
         # changed is a set
         for i in changed:
             self.changedFiles.append(i.real_path)
     except Exception as err:
         self.error = str(err)
Пример #17
0
    def rename(self, name):
        tmp0    = self.area.get('1.0', 'insert')
        offset  = len(tmp0)
        path    = self.get_root_path()
        project = Project(path)
        mod     = path_to_resource(project, self.area.filename)
        renamer = Rename(project, mod, offset)
        changes = renamer.get_changes(name)
        project.do(changes)

        self.update_instances(changes)

        print('\nRope - Renamed resource ..\n')
        print(changes.get_description())
        self.area.chmode('NORMAL')
        root.status.set_msg('Resources renamed!')
        project.close()
Пример #18
0
    def get_changes(self):
        name = worder.get_name_at(self.resource, self.offset)
        this_pymodule = self.project.get_pymodule(self.resource)
        pyname = evaluate.eval_location(this_pymodule, self.offset)
        if not self._is_a_method_local(pyname):
            raise exceptions.RefactoringError(
                'Convert local variable to field should be performed on \n'
                'a local variable of a method.')

        pymodule, lineno = pyname.get_definition_location()
        function_scope = pymodule.get_scope().get_inner_scope_for_line(lineno)
        # Not checking redefinition
        #self._check_redefinition(name, function_scope)

        new_name = self._get_field_name(function_scope.pyobject, name)
        changes = Rename(self.project, self.resource, self.offset).\
            get_changes(new_name, resources=[self.resource])
        return changes
Пример #19
0
def get_renaming_changes(project,
                         module,
                         offset,
                         new_name,
                         name,
                         source_file_name,
                         docs=True):
    """Get the changes for doing a rename refactoring.  If Rope raises a
    `RefactoringError` it prints a warning and returns `None`."""
    try:
        changes = Rename(project, module, offset).get_changes(new_name,
                                                              docs=docs,
                                                              unsure=None)
        return changes
    except rope.base.exceptions.RefactoringError:
        print("Error in calculating a rename from '{0}' to '{1}' in file"
              "\n   {2}".format(name, new_name, source_file_name))
    return None
Пример #20
0
 def run(self):
     self.error = None
     self.changedFiles = []
     try:
         self.ropeProject.validate()
         rename = Rename(self.ropeProject, libutils.path_to_resource(
             self.ropeProject, self.path), self.offset)
         changes = rename.get_changes(self.new_name)
         self.ropeProject.do(changes)
         changed = changes.get_changed_resources()
         # changed is a set
         for i in changed:
             self.changedFiles.append(i.real_path)
     except Exception as err:
         exc_type, exc_value, exc_traceback = sys.exc_info()
         logging.error(repr(traceback.format_exception(exc_type, exc_value,
                      exc_traceback)))
                          
         self.error = str(err)
def get_renaming_changes(project,
                         module,
                         offset,
                         new_name,
                         name,
                         source_file_name,
                         docs=True):
    """Get the changes for doing a rename refactoring.  Returns a tuple of the
    changes and any error that was raised.  If Rope raises certain errors such
    as `RefactoringError` it prints a warning and returns `None, e` where `e`
    is the error."""
    err_message = "Rope {} in calculating a rename from '{}' to '{}' in file\n   {}\n"
    e = None

    try:
        changes = Rename(project, module, offset).get_changes(new_name,
                                                              docs=docs,
                                                              unsure=None)
        return changes, e

    except rope.base.exceptions.RefactoringError as error:
        print_warning(
            err_message.format("RefactoringError", name, new_name,
                               source_file_name))

    except AttributeError as e:
        print_warning(
            err_message.format("AttributeError", name, new_name,
                               source_file_name))

    except SyntaxError as e:
        print_warning(
            err_message.format("SyntaxError", name, new_name,
                               source_file_name))

    except:
        print_warning(
            "Unexpected error in calculating a rename from '{}' to '{}' in file"
            "\n   {}".format(name, new_name, source_file_name))
        raise
    return None, e
Пример #22
0
    def rename_attribute(project_path: str, resource_path: str,
                         offset: Optional[int],
                         new_name: str) -> RenameChanges:
        """

        Raises:
            RefactoringError
        """
        try:
            project_manager = project.Project(project_path)
            file_resource = libutils.path_to_resource(project_manager,
                                                      resource_path)

            rename_task = Rename(project_manager, file_resource, offset)
            changes = rename_task.get_changes(new_name)

            project_manager.close()
            # return RenameChanges(changes)
            return changes

        except RefactoringError as err:
            raise ValueError(err) from err
Пример #23
0
def pyls_rename(config, workspace, document, position, new_name):
    rope_config = config.settings(document_path=document.path).get('rope', {})
    rope_project = workspace._rope_project_builder(rope_config)

    rename = Rename(
        rope_project,
        libutils.path_to_resource(rope_project, document.path),
        document.offset_at_position(position)
    )

    log.debug("Executing rename of %s to %s", document.word_at_position(position), new_name)
    changeset = rename.get_changes(new_name, in_hierarchy=True, docs=True)
    log.debug("Finished rename: %s", changeset.changes)
    changes = []
    for change in changeset.changes:
        uri = uris.from_fs_path(change.resource.path)
        doc = workspace.get_maybe_document(uri)
        changes.append({
            'textDocument': {
                'uri': uri,
                'version': doc.version if doc else None
            },
            'edits': [
                {
                    'range': {
                        'start': {'line': 0, 'character': 0},
                        'end': {
                            'line': _num_lines(change.resource),
                            'character': 0,
                        },
                    },
                    'newText': change.new_contents,
                }
            ]
        })
    return {'documentChanges': changes}
Пример #24
0
from rope.base import project
from rope.refactor.move import MoveModule
from rope.refactor.rename import Rename

my_project = project.Project('.')

providers_dest = my_project.get_folder('cfme/providers')
if not providers_dest.exists():
    providers_dest.create()

if not providers_dest.get_children():
    providers_dest.create_file('__init__.py')

folders_to_process = ['infrastructure', 'cloud', 'middleware', 'containers']

for folder in folders_to_process:

    def find(fmt):
        return my_project.find_module(fmt.format(folder=folder))

    print(folder)
    print(" append name")
    res = find('cfme.{folder}.provider')
    Rename(my_project, res).get_changes('provider_' + folder).do()
    print(" move")
    res = find('cfme.{folder}.provider_{folder}')
    MoveModule(my_project, res).get_changes(providers_dest).do()
    print(" fix_name")
    res = find('cfme.providers.provider_{folder}')
    Rename(my_project, res).get_changes(folder).do()
Пример #25
0
 def _rename(self, resource, offset, new_name, **kwds):
     changes = Rename(self.project, resource, offset).\
         get_changes(new_name, **kwds)
     self.project.do(changes)
Пример #26
0
 def rename(self, project_path, file_path, loc, source, new_name):
     project, resource = self._get_resource(project_path, file_path, source)
     rename = Rename(project, resource, loc)
     changes = rename.get_changes(new_name, in_hierarchy=True)
     project.do(changes)
Пример #27
0
from rope.base.project import Project
from rope.refactor.rename import Rename

proj = Project('src')
# resource = myProj.get_resource(r'app/src/app/services/gridMaker')
moduleToChange = proj.get_module(r'app/services/theGrid/gridLinesCoordsStore').get_resource()
change = Rename(proj, moduleToChange).get_changes('gridInfoStore')
print(change.get_description())
proj.do(change)
Пример #28
0
 def create_refactoring_operation(self, project, resource, start, end):
     return Rename(project, resource, start)
Пример #29
0
from rope.base.project import Project
from rope.refactor.rename import Rename

proj = Project('../lib/ansible')

context = proj.get_file('context.py')

change = Rename(proj, context).get_changes('new_context')

proj.do(change)
Пример #30
0
from rope.base.project import Project
from rope.refactor.rename import Rename
from rope.contrib import generate
project = Project('.')
pycore = project.pycore
package = pycore.find_module('sindice')
changes = Rename(project, package).get_changes('core')
project.do(changes)