from rope.base import evaluate, exceptions, libutils, pynames, taskhandle, utils, worder from rope.base.change import ChangeContents, ChangeSet from rope.refactor import occurrences, sourceutils class EncapsulateField: def __init__(self, project, resource, offset): self.project = project self.name = worder.get_name_at(resource, offset) this_pymodule = self.project.get_pymodule(resource) self.pyname = evaluate.eval_location(this_pymodule, offset) if not self._is_an_attribute(self.pyname): raise exceptions.RefactoringError( "Encapsulate field should be performed on class attributes." ) self.resource = self.pyname.get_definition_location()[0].get_resource() def get_changes( self, getter=None, setter=None, resources=None, task_handle=taskhandle.DEFAULT_TASK_HANDLE, ): """Get the changes this refactoring makes If `getter` is not `None`, that will be the name of the getter, otherwise ``get_${field_name}`` will be used. The same is true for `setter` and if it is None set_${field_name} is used. `resources` can be a list of `rope.base.resource.File` that the refactoring should be applied on; if `None` all python files in the project are searched. """ if resources is None: resources = self.project.get_python_files() changes = ChangeSet("Encapsulate field <%s>" % self.name) job_set = task_handle.create_jobset("Collecting Changes", len(resources)) if getter is None: getter = "get_" + self.name if setter is None: setter = "set_" + self.name renamer = GetterSetterRenameInModule( self.project, self.name, self.pyname, getter, setter ) for file in resources: job_set.started_job(file.path) if file == self.resource: result = self._change_holding_module(changes, renamer, getter, setter) changes.add_change(ChangeContents(self.resource, result)) else: result = renamer.get_changed_module(file) if result is not None: changes.add_change(ChangeContents(file, result)) job_set.finished_job() return changes def get_field_name(self): """Get the name of the field to be encapsulated""" return self.name def _is_an_attribute(self, pyname): if pyname is not None and isinstance(pyname, pynames.AssignedName): pymodule, lineno = self.pyname.get_definition_location() scope = pymodule.get_scope().get_inner_scope_for_line(lineno) if scope.get_kind() == "Class": return pyname in scope.get_names().values() parent = scope.parent if parent is not None and parent.get_kind() == "Class": return pyname in parent.get_names().values() return False def _get_defining_class_scope(self): defining_scope = self._get_defining_scope() if defining_scope.get_kind() == "Function": defining_scope = defining_scope.parent return defining_scope def _get_defining_scope(self): pymodule, line = self.pyname.get_definition_location() return pymodule.get_scope().get_inner_scope_for_line(line) def _change_holding_module(self, changes, renamer, getter, setter): pymodule = self.project.get_pymodule(self.resource) class_scope = self._get_defining_class_scope() defining_object = self._get_defining_scope().pyobject start, end = sourceutils.get_body_region(defining_object) new_source = renamer.get_changed_module( pymodule=pymodule, skip_start=start, skip_end=end ) if new_source is not None: pymodule = libutils.get_string_module( self.project, new_source, self.resource ) class_scope = pymodule.get_scope().get_inner_scope_for_line( class_scope.get_start() ) indents = sourceutils.get_indent(self.project) * " " getter = f"def {getter}(self):\n{indents}return self.{self.name}" setter = f"def {setter}(self, value):\n{indents}self.{self.name} = value" new_source = sourceutils.add_methods(pymodule, class_scope, [getter, setter]) return new_source class GetterSetterRenameInModule: def __init__(self, project, name, pyname, getter, setter): self.project = project self.name = name self.finder = occurrences.create_finder(project, name, pyname) self.getter = getter self.setter = setter def get_changed_module( self, resource=None, pymodule=None, skip_start=0, skip_end=0 ): change_finder = _FindChangesForModule( self, resource, pymodule, skip_start, skip_end ) return change_finder.get_changed_module() class _FindChangesForModule: def __init__(self, finder, resource, pymodule, skip_start, skip_end): self.project = finder.project self.finder = finder.finder self.getter = finder.getter self.setter = finder.setter self.resource = resource self.pymodule = pymodule self.last_modified = 0 self.last_set = None self.set_index = None self.skip_start = skip_start self.skip_end = skip_end def get_changed_module(self): result = [] for occurrence in self.finder.find_occurrences(self.resource, self.pymodule): start, end = occurrence.get_word_range() if self.skip_start <= start < self.skip_end: continue self._manage_writes(start, result) result.append(self.source[self.last_modified : start]) if self._is_assigned_in_a_tuple_assignment(occurrence): raise exceptions.RefactoringError( "Cannot handle tuple assignments in encapsulate field." ) if occurrence.is_written(): assignment_type = self.worder.get_assignment_type(start) if assignment_type == "=": result.append(self.setter + "(") else: var_name = ( self.source[occurrence.get_primary_range()[0] : start] + self.getter + "()" ) result.append( self.setter + "(" + var_name + " %s " % assignment_type[:-1] ) current_line = self.lines.get_line_number(start) start_line, end_line = self.pymodule.logical_lines.logical_line_in( current_line ) self.last_set = self.lines.get_line_end(end_line) end = self.source.index("=", end) + 1 self.set_index = len(result) else: result.append(self.getter + "()") self.last_modified = end if self.last_modified != 0: self._manage_writes(len(self.source), result) result.append(self.source[self.last_modified :]) return "".join(result) return None def _manage_writes(self, offset, result): if self.last_set is not None and self.last_set <= offset: result.append(self.source[self.last_modified : self.last_set]) set_value = "".join(result[self.set_index :]).strip() del result[self.set_index :] result.append(set_value + ")") self.last_modified = self.last_set self.last_set = None def _is_assigned_in_a_tuple_assignment(self, occurrence): offset = occurrence.get_word_range()[0] return self.worder.is_assigned_in_a_tuple_assignment(offset) @property @utils.saveit def source(self): if self.resource is not None: return self.resource.read() else: return self.pymodule.source_code @property @utils.saveit def lines(self): if self.pymodule is None: self.pymodule = self.project.get_pymodule(self.resource) return self.pymodule.lines @property @utils.saveit def worder(self): return worder.Worder(self.source)