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)