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 __init__(self, view, single_file=False):
self.view = view
self.project = None
self.resource = None
self.tmpfile = None
self.input = ""
self.building = False
self.file_path = self.view.file_name()
if self.file_path is None:
# unsaved buffer
self.file_path = self._create_temp_file()
self.project_dir = _find_ropeproject(self.file_path)
if not single_file and self.project_dir:
self.project = project.Project(self.project_dir,
fscommands=FileSystemCommands())
self.importer = autoimport.AutoImport(project=self.project,
observe=False)
if os.path.exists("%s/__init__.py" % self.project_dir):
sys.path.append(self.project_dir)
else:
# create a single-file project(ignoring other files in the folder)
folder = os.path.dirname(self.file_path)
ignored_res = os.listdir(folder)
ignored_res.remove(os.path.basename(self.file_path))
self.project = project.Project(ropefolder=None,
projectroot=folder,
ignored_resources=ignored_res,
fscommands=FileSystemCommands())
self.importer = autoimport.AutoImport(project=self.project,
observe=False)
def __enter__(self):
file_path = self.view.file_name()
project_dir = self.find_ropeproject(file_path)
if project_dir:
self.project = project.Project(project_dir)
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 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.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 __init__(self, path=None, project_path=None):
""" Init Rope context. """
self.path = path
self.project = project.Project(project_path,
fscommands=FileSystemCommands())
self.importer = rope_autoimport.AutoImport(project=self.project,
observe=False)
update_python_path(self.project.prefs.get('python_path', []))
self.resource = None
self.current = None
self.options = dict(
completeopt=env.var('&completeopt'),
autoimport=env.var('g:pymode_rope_autoimport', True),
autoimport_modules=env.var('g:pymode_rope_autoimport_modules'),
goto_definition_cmd=env.var('g:pymode_rope_goto_definition_cmd'),
)
if os.path.exists("%s/__init__.py" % project_path):
sys.path.append(project_path)
if self.options.get('autoimport'):
self.generate_autoimport_cache()
env.debug('Context init', project_path)
env.message('Init Rope project: %s' % project_path)
def initProject(path, script, prjFileName, classesPath):
sys.path.append(path)
global ropeProject
global lint
ropeProject = RopeProject.Project(path,
fscommands=None,
ropefolder=None,
**ROPE_PREFS)
ropeProject.validate()
try:
conf = createConfig(prjFileName)
os.chdir(path)
lint = PyLinter(pylintrc=conf, reporter=CheckReporter())
checkers.initialize(lint)
lint.read_config_file()
lint.load_config_file()
lint.load_configuration()
lint.quiet = 1
initImport(path, classesPath)
# pydevd.settrace("localhost")
except:
sys.stderr.write(traceback.format_exc())
sys.stderr.flush()
return True
def new():
""" Create a new project. """
root = None
if env.var('a:0') != '0':
root = env.var('a:1')
else:
default = env.var('g:pymode_rope_project_root')
if not default:
default = env.var('getcwd()')
root = env.var('input("Enter project root: ", "%s")' % default)
ropefolder = env.var('g:pymode_rope_ropefolder')
prj = project.Project(projectroot=root, ropefolder=ropefolder)
prj.close()
env.message("Project is opened: %s" % root)
def _PostTransferBaseStatistics (destinationBaseLibPath: str) -> None:
moduleName = "statistics" # type: str
moduleNewName = "statistics_lib" # type: str
baseProject = project.Project(destinationBaseLibPath) # type: project.Project
baseChanges = rename.Rename(baseProject, baseProject.find_module(moduleName)).get_changes(moduleNewName, docs = True)
baseProject.do(baseChanges)
baseProject.close()
# noinspection SpellCheckingInspection
ropeProjectPath = destinationBaseLibPath + os.path.sep + ".ropeproject" # type: str
try:
if os.path.exists(ropeProjectPath):
shutil.rmtree(ropeProjectPath)
except Exception as e:
print("Failed to remove the rope project directory at '" + ropeProjectPath + "'.\n" + str(e))
def revalidate(path, script, prjFileName, classesPath):
global ropeProject
global lint
ropeProject = RopeProject.Project(path,
fscommands=None,
ropefolder=None,
**ROPE_PREFS)
ropeProject.validate()
os.chdir(path)
conf = createConfig(prjFileName)
lint = PyLinter(pylintrc=conf, reporter=CheckReporter())
checkers.initialize(lint)
lint.read_config_file()
lint.load_config_file()
lint.load_configuration()
lint.quiet = 1
initImport(path, classesPath)
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
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()
def __init__(self, c):
self.c = c
if has_rope:
self.proj = project.Project(g.app.loadDir)
else:
self.proj = None
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 new():
""" Create a new project. """
root = env.var('input("Enter project root: ", getcwd())')
prj = project.Project(projectroot=root)
prj.close()
env.message("Project is opened: %s" % root)
def inspect_file(path_to_file, fileName):
'''
Return a tuple with the structure below
(globals, classes, functions).
*classes* is a list with the strcuture below:
{'name': FooClass'', 'methods': [], 'attributes':[], 'superclasses': []}.
name a string with the class name.
methods contains a list of strings.
attributes contains a list of strings.
superclasses contains a list of strings.
*functions* is a list of strings.
'''
#data stores
globals = []
classes = []
functions = []
#rope stuff
rope_project = project.Project(path_to_file)
pyCore = pycore.PyCore(rope_project)
module = pyCore.get_module(fileName)
#Collect globals definitions!
if module._get_structural_attributes().iteritems():
for attr_name, attr in module._get_structural_attributes().iteritems():
if isinstance(attr, AssignedName):
lineno = attr.get_definition_location()[1]
d_global = {'name': attr_name, 'lineno': lineno - 1}
globals.append(d_global)
#This way I get only classes and functions defined in the file!
if module._get_defined_objects():
for obj in module._get_defined_objects():
#this is a class!
if isinstance(obj, AbstractClass):
lineno = obj.get_scope().get_start()
d = {
'name': obj.get_name(),
'lineno': lineno - 1,
'methods': [],
'attributes': [],
'inside-classes': [],
'superclasses': []
}
#bases
for klass in obj.get_superclasses():
if isinstance(klass, AbstractClass):
d['superclasses'].append(klass.get_name())
#attributes
for attr_name, attr in obj.get_attributes().iteritems():
if isinstance(attr, AssignedName):
#TRICK: Si el atributo pertenece al mismo modulo(archivo) que estoy analizando
#entonces podremos usar "go_to_line" sino lo descartamos
if attr.lineno and attr.module.get_resource(
).name[:-3] == fileName:
#lineno = obj[attr_name].get_definition_location()[1]
lineno = attr.lineno
d_attribute = {
'name': attr_name,
'lineno': lineno - 1
}
d['attributes'].append(d_attribute)
#methods
elif isinstance(attr, DefinedName):
#Debe ser un metodo
if isinstance(attr.get_object(), AbstractFunction):
#TRICK: Si el metodo pertenece a la clase que estoy analizando
if attr.get_object().parent.get_name(
) == obj.get_name():
method_signature = create_signature(
attr.get_object().get_name(),
attr.get_object().get_param_names())
lineno = attr.get_object().get_scope(
).get_start()
d_method = {
'name': method_signature,
'lineno': lineno - 1
}
d['methods'].append(d_method)
#sort attributes and methods
d['attributes'].sort(key=lambda d: d['name'])
d['methods'].sort(key=lambda d: d['name'])
#appent the class with attributes and methods
classes.append(d)
#this is a function!
elif isinstance(obj, AbstractFunction):
func_signature = create_signature(obj.get_name(),
obj.get_param_names())
lineno = obj.get_scope().get_start()
d_function = {'name': func_signature, 'lineno': lineno - 1}
functions.append(d_function)
#sort globals, classes and functions
globals.sort(key=lambda d: d['name'])
classes.sort(key=lambda d: d['name'])
functions.sort(key=lambda d: d['name'])
return (globals, classes, functions)
