def _discard_update(item):
resource_obj = resource.load(item.res)
old_connections = resource_obj.connections
new_connections = dictdiffer.revert(item.signals_diff, sorted(old_connections))
args = dictdiffer.revert(item.diff, resource_obj.args)
_update_inputs_connections(
resource_obj, args, old_connections, new_connections)
def _discard_update(item):
resource_obj = resource.load(item.resource)
old_connections = resource_obj.connections
new_connections = dictdiffer.revert(
item.connections_diff, sorted(old_connections))
inputs = dictdiffer.revert(item.diff, resource_obj.args)
_update_inputs_connections(
resource_obj, _get_args_to_update(inputs, old_connections),
old_connections, new_connections)
def _discard_update(item):
resource_obj = resource.load(item.resource)
old_connections = resource_obj.connections
new_connections = dictdiffer.revert(item.connections_diff,
sorted(old_connections))
inputs = dictdiffer.revert(item.diff, resource_obj.args)
_update_inputs_connections(resource_obj,
_get_args_to_update(inputs, old_connections),
old_connections, new_connections)
def undo(self):
if self.active + 1 >= len(self):
return self.active
delta = self[self.active]
with self.handler.root:
self.handler.track = False
dictdiffer.revert(delta, self.handler.root, in_place=True)
self.handler.track = True
self.active += 1
return self.active
def _revert_remove(logitem):
"""Resource should be created with all previous connections
"""
commited = orm.DBCommitedState.load(logitem.res)
args = dictdiffer.revert(logitem.diff, commited.inputs)
connections = dictdiffer.revert(logitem.signals_diff, sorted(commited.connections))
resource.Resource(logitem.res, logitem.base_path, args=args, tags=commited.tags)
for emitter, emitter_input, receiver, receiver_input in connections:
emmiter_obj = resource.load(emitter)
receiver_obj = resource.load(receiver)
signals.connect(emmiter_obj, receiver_obj, {emitter_input: receiver_input})
def _revert_update(logitem):
"""Revert of update should update inputs and connections
"""
res_obj = resource.load(logitem.res)
commited = res_obj.load_commited()
args_to_update = dictdiffer.revert(logitem.diff, commited.inputs)
connections = dictdiffer.revert(logitem.signals_diff, sorted(commited.connections))
_update_inputs_connections(
res_obj, args_to_update, commited.connections, connections)
def _revert_update(logitem):
"""Revert of update should update inputs and connections"""
res_obj = resource.load(logitem.resource)
commited = res_obj.load_commited()
connections = dictdiffer.revert(logitem.connections_diff,
sorted(commited.connections))
args = dictdiffer.revert(logitem.diff, commited.inputs)
_update_inputs_connections(res_obj, _get_args_to_update(args, connections),
commited.connections, connections)
def _revert_remove(logitem):
"""Resource should be created with all previous connections"""
commited = CommitedResource.get(logitem.resource)
args = dictdiffer.revert(logitem.diff, commited.inputs)
connections = dictdiffer.revert(
logitem.connections_diff, sorted(commited.connections))
resource.Resource(logitem.resource, logitem.base_path,
args=_get_args_to_update(args, connections),
tags=commited.tags)
for emitter, emitter_input, receiver, receiver_input in connections:
emmiter_obj = resource.load(emitter)
receiver_obj = resource.load(receiver)
signals.connect(emmiter_obj, receiver_obj, {
emitter_input: receiver_input})
def _revert_remove(logitem):
"""Resource should be created with all previous connections"""
commited = CommitedResource.get(logitem.resource)
args = dictdiffer.revert(logitem.diff, commited.inputs)
connections = dictdiffer.revert(
logitem.connections_diff, sorted(commited.connections))
resource.Resource(logitem.resource, logitem.base_path,
args=_get_args_to_update(args, connections),
tags=commited.tags)
for emitter, emitter_input, receiver, receiver_input in connections:
emmiter_obj = resource.load(emitter)
receiver_obj = resource.load(receiver)
signals.connect(emmiter_obj, receiver_obj, {
emitter_input: receiver_input})
def test_revert(self):
first = {'a': 'b'}
second = {'a': 'c'}
diffed = diff(first, second)
patched = patch(diffed, first)
assert patched == second
diffed = diff(first, second)
reverted = revert(diffed, second)
assert reverted == first
def test_revert(self):
first = {"a": [1, 2]}
second = {"a": []}
diffed = diff(first, second)
patched = patch(diffed, first)
assert patched == second
diffed = diff(first, second)
reverted = revert(diffed, second)
assert reverted == first
def test_revert(self):
first = {'a': [1, 2]}
second = {'a': []}
diffed = diff(first, second)
patched = patch(diffed, first)
assert patched == second
diffed = diff(first, second)
reverted = revert(diffed, second)
assert reverted == first
def test_in_place_patch_and_revert(self):
first = {'a': 1}
second = {'a': 2}
changes = list(diff(first, second))
patched_copy = patch(changes, first)
assert first != patched_copy
reverted_in_place = revert(changes, patched_copy, in_place=True)
assert first == reverted_in_place
assert patched_copy == reverted_in_place
patched_in_place = patch(changes, first, in_place=True)
assert first == patched_in_place
def test_in_place_patch_and_revert(self):
first = {'a': 1}
second = {'a': 2}
changes = list(diff(first, second))
patched_copy = patch(changes, first)
assert first != patched_copy
reverted_in_place = revert(changes, patched_copy, in_place=True)
assert first == reverted_in_place
assert patched_copy == reverted_in_place
patched_in_place = patch(changes, first, in_place=True)
assert first == patched_in_place
def get_history(self, n=-1, **kwargs):
try:
n = int(n)
except (TypeError, ValueError):
raise TypeError(
'Amount of history items must be integer representable: "%s" isn\'t'
% (n, ))
current_version = self.content
history = [current_version]
doc_delta_set = DocDelta.objects.all().filter(
**kwargs).order_by('-created')
for doc_delta in doc_delta_set:
previous_version = revert(doc_delta.delta, current_version)
history.append(previous_version)
current_version = previous_version
if n >= 0:
return history[:n]
return history
def get_prev_versions(cls, object, limit=1):
current_db_state_of_objects = object.__class__.objects.get(
id=object.id)
second = json.loads(
serializers.serialize('json', [current_db_state_of_objects]))[0]
previous_versions = []
queryset = cls.objects.filter(
object_type=second["model"],
object_id=second["pk"]).order_by("-id")[:limit]
for audit_log in queryset:
diff = json.loads(audit_log.state_delta)
first = dictdiffer.revert(diff, second)
if first == {}:
break
previous_versions.append(first)
second = first
previous_version_objects = []
for version in serializers.deserialize('json',
json.dumps(previous_versions)):
previous_version_objects.append(version.object)
return previous_version_objects
def test_revert_update(staged, diff_for_update, commited):
expected = revert(diff_for_update, staged)
assert expected == commited
def test_list_of_different_length(self):
"""Check that one can revert list with different length."""
first = [1]
second = [1, 2, 3]
result = list(diff(first, second))
assert first == revert(result, second)
def test_list_of_different_length(self):
"""Check that one can revert list with different length."""
first = [1]
second = [1, 2, 3]
result = list(diff(first, second))
assert first == revert(result, second)
def test_revert_update(staged, diff_for_update, commited):
expected = revert(diff_for_update, staged)
assert expected == commited
def revert(change, target, copy_original = True): return dictdiffer.revert(change, target, copy_original)
