def test_simple_path_to_resource(self): myfile = self.project.root.create_file("myfile.txt") self.assertEquals(myfile, path_to_resource(self.project, myfile.real_path)) self.assertEquals(myfile, path_to_resource(self.project, myfile.real_path, type="file")) myfolder = self.project.root.create_folder("myfolder") self.assertEquals(myfolder, path_to_resource(self.project, myfolder.real_path)) self.assertEquals(myfolder, path_to_resource(self.project, myfolder.real_path, type="folder"))
def test_simple_path_to_resource(self): myfile = self.project.root.create_file('myfile.txt') self.assertEquals(myfile, path_to_resource(self.project, myfile.real_path)) self.assertEquals(myfile, path_to_resource( self.project, myfile.real_path, type='file')) myfolder = self.project.root.create_folder('myfolder') self.assertEquals(myfolder, path_to_resource(self.project, myfolder.real_path)) self.assertEquals(myfolder, path_to_resource( self.project, myfolder.real_path, type='folder'))
def test_out_of_project_files_and_path_to_resource(self): sample_file_path = os.path.join(self.test_directory, "sample.txt") sample_file = file(sample_file_path, "w") sample_file.write("sample content\n") sample_file.close() sample_resource = self.no_project.get_resource(sample_file_path) self.assertEquals(sample_resource, path_to_resource(self.project, sample_file_path))
def extract_variable(_, multiproj, main_project, other_projects, file_path, cursor_position_start, cursor_position_end, replacement): """ Extract variable from selection """ try: main_project.validate() module = libutils.path_to_resource(main_project, file_path) if multiproj: # we need to rename cross project crossrename = multiproject.MultiProjectRefactoring( ExtractVariable, other_projects) extractor = crossrename( main_project, module, cursor_position_start, cursor_position_end) pending_changes = extractor.get_all_changes(replacement) else: extractor = ExtractVariable( main_project, module, cursor_position_start, cursor_position_end) pending_changes = extractor.get_changes(replacement, similar=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
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)
def __enter__(self): file_path = self.view.file_name() if file_path is None: # unsaved buffer file_path = self.create_temp_file() project_dir = self.find_ropeproject(file_path) if project_dir: self.project = project.Project(project_dir) self.importer = autoimport.AutoImport( project=self.project, observe=True) if not os.path.exists("%s/.ropeproject/globalnames" % project_dir): self.importer.generate_cache() if os.path.exists("%s/__init__.py" % project_dir): sys.path.append(project_dir) else: # create a single-file project(ignoring other files in the folder) folder = os.path.dirname(file_path) ignored_res = os.listdir(folder) ignored_res.remove(os.path.basename(file_path)) self.project = project.Project( ropefolder=None, projectroot=folder, ignored_resources=ignored_res) self.importer = autoimport.AutoImport( project=self.project, observe=True) self.resource = libutils.path_to_resource(self.project, file_path) update_python_path(self.project.prefs.get('python_path', [])) self.input = self.view.substr(sublime.Region(0, self.view.size())) return self
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
def _get_resource(self, filename=None): if filename is None: filename = self.env.filename() if filename is None or self.project is None: return resource = libutils.path_to_resource(self.project, filename, 'file') return resource
def _get_resource(self, filename=None): if filename is None: filename = lisp.buffer_file_name() if filename is None: return resource = libutils.path_to_resource(self.project, filename, 'file') return resource
def __enter__(self): project_dir = os.environ.get('TM_PROJECT_DIRECTORY', None) file_path = os.environ['TM_FILEPATH'] if project_dir: self.project = project.Project(project_dir) # no use to have auto import for a single file project if not os.path.exists("%s/.ropeproject/globalnames" % project_dir): importer = autoimport.AutoImport(project=self.project, observe=True) importer.generate_cache() if os.path.exists("%s/__init__.py" % project_dir): sys.path.append(project_dir) else: #create a single-file project (ignoring all other files in the file's folder) folder = os.path.dirname(file_path) ignored_res = os.listdir(folder) ignored_res.remove(os.path.basename(file_path)) self.project = project.Project( ropefolder=None,projectroot=folder, ignored_resources=ignored_res) self.resource = libutils.path_to_resource(self.project, file_path) update_python_path( self.project.prefs.get('python_path', []) ) self.input = sys.stdin.read() return self
def documentation(self, source, project_path, file_path, loc): project, file_path = self.project_for(project_path, file_path, source) resource = libutils.path_to_resource(project, file_path) try: doc = get_doc(project, source, loc, resource=resource, maxfixes=3) except ModuleSyntaxError: doc = None return doc
def __init__(self, project_root, filename): self.project_root = project_root if ROPE_AVAILABLE: self.project = Project(project_root, ropefolder=None) self.resource = path_to_resource(self.project, filename) else: self.project = None self.resource = FakeResource(filename)
def __init__(self, project_root, filename): self.project_root = project_root if ROPE_AVAILABLE: self.project = Project(project_root, ropefolder=None) self.resource = path_to_resource(self.project, filename) else: raise Fault('rope not installed, cannot refactor code.', code=400)
def definition_location(self, source, project_path, file_path, loc): project = self.project_for(project_path, file_path) resource = libutils.path_to_resource(project, file_path) try: def_resource, def_lineno = get_definition_location( project, source, loc, resource=resource, maxfixes=3) except ModuleSyntaxError: return None, None return def_resource.real_path, def_lineno
def __init__(self, project_root, filename): self.project_root = project_root if ROPE_AVAILABLE: self.project = Project(project_root) self.resource = path_to_resource(self.project, filename) else: self.project = None with open(filename) as f: self.resource = StringIO(f.read())
def run(self): self.error = None try: convert = ModuleToPackage(self.ropeProject, libutils.path_to_resource(self.ropeProject, self.path)) changes = convert.get_changes() self.ropeProject.do(changes) except Exception as err: self.error = str(err)
def get_definition_location(self): if not inspect.isbuiltin(self.pyobject): _lines, lineno = inspect.getsourcelines(self.pyobject.builtin) path = inspect.getfile(self.pyobject.builtin) pycore = self._pycore() if pycore and pycore.project: resource = libutils.path_to_resource(pycore.project, path) module = pyobjects.PyModule(pycore, None, resource) return (module, lineno) return (None, None)
def extract_variable(self, action): "Extracts a variable from expression selected in a document" self.validate_project() doc = self.window.get_active_document() start, end = doc.get_selection_bounds() resource = libutils.path_to_resource(self.project, doc.get_uri_for_display()) extractor = ExtractVariable(self.project, resource, start.get_offset(), end.get_offset()) txt = dialogs.get_python_identifier() if txt: changes = extractor.get_changes(txt) self.apply_changes(changes)
def __enter__(self): env.let("g:pymode_rope_current", self.project.root.real_path) self.project.validate(self.project.root) self.resource = libutils.path_to_resource(self.project, env.curbuf.name, "file") if not self.resource.exists() or os.path.isdir(self.resource.real_path): self.resource = None else: env.debug("Found resource", self.resource.path) return self
def __enter__(self): self.project.validate(self.project.root) self.resource = libutils.path_to_resource( self.project, env.curbuf.name, 'file') if not self.resource.exists() or os.path.isdir( self.resource.real_path): self.resource = None else: env.debug('Found resource', self.resource.path) return self
def __init__(self, project_root, filename): self.project_root = project_root if not ROPE_AVAILABLE: raise Fault('rope not installed, cannot refactor code.', code=400) if not os.path.exists(project_root): raise Fault( "cannot do refactoring without a local project root", code=400 ) self.project = Project(project_root, ropefolder=None) self.resource = path_to_resource(self.project, filename)
def run(self): self.error = None try: convert = ModuleToPackage(self.ropeProject, libutils.path_to_resource(self.ropeProject, self.path)) changes = convert.get_changes() self.ropeProject.do(changes) 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 _create(self, name, callback, parentname="source"): self._check_project() confs = {"name": dialog.Data(name.title() + " name: ")} parentname = parentname + "folder" optionals = { parentname: dialog.Data(parentname.title() + " Folder: ", default=self.project.address, kind="directory") } action, values = dialog.show_dialog(self._askdata, ["perform", "cancel"], confs, optionals) if action == "perform": parent = libutils.path_to_resource(self.project, values.get(parentname, self.project.address)) resource = callback(parent, values["name"]) if resource: self.env.find_file(resource.real_path)
def getOccurencesForFilePosition( fileName, position, throwException ): " Provides a list of the token at position occurences " result = [] try: GlobalData().validateRopeProject() ropeProject = GlobalData().getRopeProject( fileName ) resource = path_to_resource( ropeProject, fileName ) result = find_occurrences( ropeProject, resource, position, True ) except: if throwException: raise return _buildOccurrencesImplementationsResult( result )
def get_rope_resource(self, project, uri=None): from rope.base import libutils, exceptions uri = uri or self.editor.uri if not hasattr(project, 'address'): return project.get_file(uri) else: try: return libutils.path_to_resource(project, uri) except exceptions.ResourceNotFoundError: from rope.base.project import NoProject resource = NoProject().get_file(uri) resource.read = lambda: '' return resource
def __enter__(self): """ Enter to Rope ctx. """ env.let('g:pymode_rope_current', self.project.root.real_path) self.project.validate(self.project.root) self.resource = libutils.path_to_resource( self.project, env.curbuf.name, 'file') if not self.resource.exists() or os.path.isdir( self.resource.real_path): self.resource = None else: env.debug('Found resource', self.resource.path) return self
def _extractMethod(self, filePath, start, end, newName): """ Extracts a method """ project = rope.base.project.Project(WORKSPACE_ROOT, ropefolder=ROPE_PROJECT_FOLDER, save_history=False) resourceToRefactor = libutils.path_to_resource(project, filePath) refactor = ExtractMethodRefactor(project, resourceToRefactor, startOffset=start, endOffset=end, newName=newName) refactor.refactor() changes = refactor.changes project.close() valueToReturn = [] for change in changes: valueToReturn.append({'diff':change.diff}) return valueToReturn
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)
def _create(self, name, callback, parentname='source'): self._check_project() confs = {'name': dialog.Data(name.title() + ' name: ')} parentname = parentname + 'folder' optionals = {parentname: dialog.Data( parentname.title() + ' Folder: ', default=self.project.address, kind='directory')} action, values = dialog.show_dialog( self._askdata, ['perform', 'cancel'], confs, optionals) if action == 'perform': parent = libutils.path_to_resource( self.project, values.get(parentname, self.project.address)) resource = callback(parent, values['name']) if resource: self.env.find_file(resource.real_path)
def _rename(self, filePath, start, newName, indent_size): """ Renames a variable """ project = rope.base.project.Project( WORKSPACE_ROOT, ropefolder=ROPE_PROJECT_FOLDER, save_history=False, indent_size=indent_size) resourceToRefactor = libutils.path_to_resource(project, filePath) refactor = RenameRefactor( project, resourceToRefactor, startOffset=start, newName=newName) refactor.refactor() changes = refactor.changes project.close() valueToReturn = [] for change in changes: valueToReturn.append({'diff': change.diff}) return valueToReturn
# source: https://github.com/python-rope/rope/issues/231 """ Tu chyba chodzi o przeniesienie klasy do pliku, który już istnieje... o.O Po co to komu? Wrzucam sobie jako ściągę, bo: - może kiedyś mi się przyda - dobrze pokazuje użycie 'resource'ów (właśc: libutils.path_to_resource ) """ import rope.base.project from rope.base import libutils from rope.refactor import move my_project = rope.base.project.Project('src') path_a = r'src/app/services/gridMaker/grid.py' path_b = r'src/app/services/grid.py' origin = libutils.path_to_resource(my_project, path_a) destination = libutils.path_to_resource(my_project, path_b) move_object = move.create_move(my_project, origin) changes = move_object.get_changes(destination) my_project.do(changes)
def _change_project_resource(self, project, obj): if isinstance(obj, resources.Resource) and obj.project != project: return libutils.path_to_resource(project, obj.real_path) return obj
import rope.base.project from rope.base import libutils from rope.refactor.extract import ExtractVariable project = rope.base.project.Project('../lib/ansible') resource = libutils.path_to_resource( project, '../lib/ansible/collections/list.py') extractor = ExtractVariable(project, resource, 1, 50) changes = extractor.get_changes('extracted_variable') project.do(changes)
from rope.base.project import Project from rope.base import libutils from rope.refactor.move import create_move myProj = Project('src') # resource = myProj.get_resource(r'app/services/gridMaker/grid.py') # resource = libutils.path_to_resource(myProj, r'src/app/services/gridMaker') resource = myProj.get_resource(r'app/services/theGrid/windowSetter.py') offset = None destination = libutils.path_to_resource( myProj, r'src/app/services/theGrid/windowSetter') mover = create_move(myProj, resource, offset) myProj.do(mover.get_changes(destination))
def _rope_resource(self, rope_config): # pylint: disable=import-outside-toplevel from rope.base import libutils return libutils.path_to_resource( self._rope_project_builder(rope_config), self.path)
def getCalltipAndDoc(fileName, editor, position=None, tryQt=False): " Provides a calltip and docstring " try: GlobalData().validateRopeProject() ropeProject = GlobalData().getRopeProject(fileName) if position is None: position = editor.currentPosition() text = editor.text() calltip = None docstring = None resource = None if os.path.isabs(fileName): resource = path_to_resource(ropeProject, fileName) calltip = get_calltip(ropeProject, text, position, resource, ignore_unknown=False, remove_self=True, maxfixes=7) if calltip is not None: calltip = calltip.strip() while '..' in calltip: calltip = calltip.replace('..', '.') if '(.)' in calltip: calltip = calltip.replace('(.)', '(...)') calltip = calltip.replace('.__init__', '') try: docstring = get_doc(ropeProject, text, position, resource, maxfixes=7) except: pass if not calltip: calltip = None if tryQt and calltip is not None and docstring is not None: # try to extract signatures from the QT docstring try: if calltip.startswith('QtCore.') or calltip.startswith( 'QtGui.'): parenPos = calltip.index("(") dotPos = calltip.rindex(".", 0, parenPos) pattern = calltip[dotPos:parenPos + 1] signatures = [] for line in docstring.splitlines(): line = line.strip() if pattern in line and not line.endswith(':'): signatures.append(line) if signatures: calltip = '\n'.join(signatures) except: pass if calltip: # Sometimes rope makes a mistake and provides a calltip for the # wrong function. Check the name here. line, index = editor.lineIndexFromPosition(position) word = str(editor.getWord(line, index)) if word and not (word.startswith('__') and word.endswith('__')): fullName = calltip.split('(', 1)[0].strip() lastPart = fullName.split('.')[-1] if lastPart != word: # Wrong calltip # print "Wrong calltip. Asked: '" + word + "' received: '" + lastPart + "'" # print calltip return None, None return calltip, docstring except: return None, None
def _get_resource(self, project_path, file_path, source): """Get and returns project and resource objects from Rope library """ project, file_path = self.project_for(project_path, file_path, source) return project, libutils.path_to_resource(project, file_path)
def _rope_resource(self, rope_config): from rope.base import libutils return libutils.path_to_resource(self._rope_project_builder(rope_config), self.path)
import argparse from rope.base import libutils, project from rope.refactor.extract import ExtractVariable parser = argparse.ArgumentParser() parser.add_argument('path', type=str) parser.add_argument('file', type=str) parser.add_argument('start', type=int) parser.add_argument('end', type=int) parser.add_argument('name', type=str) args = parser.parse_args() project_path = args.path base_project = project.Project(project_path) file_path = args.file resource = libutils.path_to_resource(base_project, file_path) start, end = args.start - 1, args.end extractor = ExtractVariable(base_project, resource, start, end) variable_name = args.name changes = extractor.get_changes(variable_name, similar=True) print(changes.get_description()) # base_project.do(changes)
def find_usages(_, main_project, other_projects, file_path, offset): """ Find usages of symbol under cursor. """ try: occurrences = [] if other_projects: for path in [main_project] + other_projects: prj = Project(path, ropefolder=api.project.FOLDER, fscommands=FileSystemCommands()) prj.validate() mod = libutils.path_to_resource(prj, file_path) occurrences += find_occurrences(prj, mod, offset, unsure=False, in_hierarchy=True) prj.close() else: prj = Project(main_project, ropefolder=api.project.FOLDER, fscommands=FileSystemCommands()) prj.validate() mod = libutils.path_to_resource(prj, file_path) occurrences = find_occurrences(prj, mod, offset, unsure=False, in_hierarchy=True) # transform results to a serialisable list of usages that is ready # to use by the find_results widget. occurrences_map = {} for location in occurrences: path = location.resource.real_path lineno = location.lineno - 1 # convert file region to line region content = location.resource.read() offset = location.offset char = content[offset] while char != '\n': # find start of line offset -= 1 char = content[offset] # update offsets start = location.offset - offset - 1 end = location.region[1] - offset - 1 line_text = content.splitlines()[lineno] data = (lineno, line_text, [(start, end)]) if path not in occurrences_map: occurrences_map[path] = [data] else: occurrences_map[path].append(data) results = [] for key, value in occurrences_map.items(): results.append((key, value)) results = sorted(results, key=lambda x: x[0]) return results 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
def refactor_move_module(self, new_name): """Move the current module.""" refactor = create_move(self.project, self.resource) resource = path_to_resource(self.project, new_name) return self._get_changes(refactor, resource)
def _rope(self): return libutils.path_to_resource(self._rope_project, self.path)
print('Domain specific models are moving to related api packages.') with open(sdk_generated_path + 'opsgenieCodegenModels.csv', mode='r') as csv_file: csv_reader = csv.DictReader(csv_file) for row in csv_reader: if row['opsgenieDomain'] != 'common': model_resource = libutils.path_to_resource(project, sdk_generated_path + sdk_path + 'models/' + row['classFilename'] + '.py', 'file') model_dest_resource = libutils.path_to_resource(project, sdk_generated_path + sdk_path + 'api/' + row['opsgenieDomain'], 'folder') if model_resource.exists() and model_dest_resource.exists(): print('\tclassname: ' + row["classname"] + ' classFilename: ' + row["classFilename"] + ' opsgenieDomain: ' + row["opsgenieDomain"]) moveModule = MoveModule(project, model_resource) changes = moveModule.get_changes(model_dest_resource) project.do(changes) project = rope.base.project.Project(sdk_generated_path) api_resources = libutils.path_to_resource(project, sdk_generated_path + sdk_path + 'api', 'folder') move_all_api_modules_to_package() rename_all_api_modules() move_domain_models() project.close()
def get_rope_resource(self, project, uri=None): uri = uri or self.editor.uri return libutils.path_to_resource(project, File(uri).get_path())
def __enter__(self): self.resource = libutils.path_to_resource(self.project, self.file_path) _update_python_path(self.project.prefs.get('python_path', [])) self.input = self.view.substr(sublime.Region(0, self.view.size())) return self