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
