230 lines
8.2 KiB
Python
230 lines
8.2 KiB
Python
from rope.base import exceptions, change, taskhandle
|
|
|
|
|
|
class History(object):
|
|
"""A class that holds project history"""
|
|
|
|
def __init__(self, project, maxundos=None):
|
|
self.project = project
|
|
self._undo_list = []
|
|
self._redo_list = []
|
|
self._maxundos = maxundos
|
|
self._load_history()
|
|
self.project.data_files.add_write_hook(self.write)
|
|
self.current_change = None
|
|
|
|
def _load_history(self):
|
|
if self.save:
|
|
result = self.project.data_files.read_data(
|
|
"history", compress=self.compress, import_=True
|
|
)
|
|
if result is not None:
|
|
to_change = change.DataToChange(self.project)
|
|
for data in result[0]:
|
|
self._undo_list.append(to_change(data))
|
|
for data in result[1]:
|
|
self._redo_list.append(to_change(data))
|
|
|
|
def do(self, changes, task_handle=taskhandle.NullTaskHandle()):
|
|
"""Perform the change and add it to the `self.undo_list`
|
|
|
|
Note that uninteresting changes (changes to ignored files)
|
|
will not be appended to `self.undo_list`.
|
|
|
|
"""
|
|
try:
|
|
self.current_change = changes
|
|
changes.do(change.create_job_set(task_handle, changes))
|
|
finally:
|
|
self.current_change = None
|
|
if self._is_change_interesting(changes):
|
|
self.undo_list.append(changes)
|
|
self._remove_extra_items()
|
|
del self.redo_list[:]
|
|
|
|
def _remove_extra_items(self):
|
|
if len(self.undo_list) > self.max_undos:
|
|
del self.undo_list[0 : len(self.undo_list) - self.max_undos]
|
|
|
|
def _is_change_interesting(self, changes):
|
|
for resource in changes.get_changed_resources():
|
|
if not self.project.is_ignored(resource):
|
|
return True
|
|
return False
|
|
|
|
def undo(self, change=None, drop=False, task_handle=taskhandle.NullTaskHandle()):
|
|
"""Redo done changes from the history
|
|
|
|
When `change` is `None`, the last done change will be undone.
|
|
If change is not `None` it should be an item from
|
|
`self.undo_list`; this change and all changes that depend on
|
|
it will be undone. In both cases the list of undone changes
|
|
will be returned.
|
|
|
|
If `drop` is `True`, the undone change will not be appended to
|
|
the redo list.
|
|
|
|
"""
|
|
if not self._undo_list:
|
|
raise exceptions.HistoryError("Undo list is empty")
|
|
if change is None:
|
|
change = self.undo_list[-1]
|
|
dependencies = self._find_dependencies(self.undo_list, change)
|
|
self._move_front(self.undo_list, dependencies)
|
|
self._perform_undos(len(dependencies), task_handle)
|
|
result = self.redo_list[-len(dependencies) :]
|
|
if drop:
|
|
del self.redo_list[-len(dependencies) :]
|
|
return result
|
|
|
|
def redo(self, change=None, task_handle=taskhandle.NullTaskHandle()):
|
|
"""Redo undone changes from the history
|
|
|
|
When `change` is `None`, the last undone change will be
|
|
redone. If change is not `None` it should be an item from
|
|
`self.redo_list`; this change and all changes that depend on
|
|
it will be redone. In both cases the list of redone changes
|
|
will be returned.
|
|
|
|
"""
|
|
if not self.redo_list:
|
|
raise exceptions.HistoryError("Redo list is empty")
|
|
if change is None:
|
|
change = self.redo_list[-1]
|
|
dependencies = self._find_dependencies(self.redo_list, change)
|
|
self._move_front(self.redo_list, dependencies)
|
|
self._perform_redos(len(dependencies), task_handle)
|
|
return self.undo_list[-len(dependencies) :]
|
|
|
|
def _move_front(self, change_list, changes):
|
|
for change in changes:
|
|
change_list.remove(change)
|
|
change_list.append(change)
|
|
|
|
def _find_dependencies(self, change_list, change):
|
|
index = change_list.index(change)
|
|
return _FindChangeDependencies(change_list[index:])()
|
|
|
|
def _perform_undos(self, count, task_handle):
|
|
for i in range(count):
|
|
self.current_change = self.undo_list[-1]
|
|
try:
|
|
job_set = change.create_job_set(task_handle, self.current_change)
|
|
self.current_change.undo(job_set)
|
|
finally:
|
|
self.current_change = None
|
|
self.redo_list.append(self.undo_list.pop())
|
|
|
|
def _perform_redos(self, count, task_handle):
|
|
for i in range(count):
|
|
self.current_change = self.redo_list[-1]
|
|
try:
|
|
job_set = change.create_job_set(task_handle, self.current_change)
|
|
self.current_change.do(job_set)
|
|
finally:
|
|
self.current_change = None
|
|
self.undo_list.append(self.redo_list.pop())
|
|
|
|
def contents_before_current_change(self, file):
|
|
if self.current_change is None:
|
|
return None
|
|
result = self._search_for_change_contents([self.current_change], file)
|
|
if result is not None:
|
|
return result
|
|
if file.exists() and not file.is_folder():
|
|
return file.read()
|
|
else:
|
|
return None
|
|
|
|
def _search_for_change_contents(self, change_list, file):
|
|
for change_ in reversed(change_list):
|
|
if isinstance(change_, change.ChangeSet):
|
|
result = self._search_for_change_contents(change_.changes, file)
|
|
if result is not None:
|
|
return result
|
|
if isinstance(change_, change.ChangeContents) and change_.resource == file:
|
|
return change_.old_contents
|
|
|
|
def write(self):
|
|
if self.save:
|
|
data = []
|
|
to_data = change.ChangeToData()
|
|
self._remove_extra_items()
|
|
data.append([to_data(change_) for change_ in self.undo_list])
|
|
data.append([to_data(change_) for change_ in self.redo_list])
|
|
self.project.data_files.write_data("history", data, compress=self.compress)
|
|
|
|
def get_file_undo_list(self, resource):
|
|
result = []
|
|
for change in self.undo_list:
|
|
if resource in change.get_changed_resources():
|
|
result.append(change)
|
|
return result
|
|
|
|
def __str__(self):
|
|
return "History holds %s changes in memory" % (
|
|
len(self.undo_list) + len(self.redo_list)
|
|
)
|
|
|
|
undo_list = property(lambda self: self._undo_list)
|
|
redo_list = property(lambda self: self._redo_list)
|
|
|
|
@property
|
|
def tobe_undone(self):
|
|
"""The last done change if available, `None` otherwise"""
|
|
if self.undo_list:
|
|
return self.undo_list[-1]
|
|
|
|
@property
|
|
def tobe_redone(self):
|
|
"""The last undone change if available, `None` otherwise"""
|
|
if self.redo_list:
|
|
return self.redo_list[-1]
|
|
|
|
@property
|
|
def max_undos(self):
|
|
if self._maxundos is None:
|
|
return self.project.prefs.get("max_history_items", 100)
|
|
else:
|
|
return self._maxundos
|
|
|
|
@property
|
|
def save(self):
|
|
return self.project.prefs.get("save_history", False)
|
|
|
|
@property
|
|
def compress(self):
|
|
return self.project.prefs.get("compress_history", False)
|
|
|
|
def clear(self):
|
|
"""Forget all undo and redo information"""
|
|
del self.undo_list[:]
|
|
del self.redo_list[:]
|
|
|
|
|
|
class _FindChangeDependencies(object):
|
|
def __init__(self, change_list):
|
|
self.change = change_list[0]
|
|
self.change_list = change_list
|
|
self.changed_resources = set(self.change.get_changed_resources())
|
|
|
|
def __call__(self):
|
|
result = [self.change]
|
|
for change in self.change_list[1:]:
|
|
if self._depends_on(change, result):
|
|
result.append(change)
|
|
self.changed_resources.update(change.get_changed_resources())
|
|
return result
|
|
|
|
def _depends_on(self, changes, result):
|
|
for resource in changes.get_changed_resources():
|
|
if resource is None:
|
|
continue
|
|
if resource in self.changed_resources:
|
|
return True
|
|
for changed in self.changed_resources:
|
|
if resource.is_folder() and resource.contains(changed):
|
|
return True
|
|
if changed.is_folder() and changed.contains(resource):
|
|
return True
|
|
return False
|