X-Git-Url: https://git.mdrn.pl/redakcja.git/blobdiff_plain/bc6587a11ccc72c7f4bf525f9b37fedc15f8bfa5..21e60dff855cacb585e159850e2de899d4622e5d:/lib/wlrepo/mercurial_backend/document.py diff --git a/lib/wlrepo/mercurial_backend/document.py b/lib/wlrepo/mercurial_backend/document.py old mode 100644 new mode 100755 index 3911d042..35779d82 --- a/lib/wlrepo/mercurial_backend/document.py +++ b/lib/wlrepo/mercurial_backend/document.py @@ -106,10 +106,19 @@ class MercurialDocument(wlrepo.Document): return self._library.document_for_rev(fullid) def up_to_date(self): - return self.ismain() or (\ - self.shared().ancestorof(self) ) + if self.ismain(): + return True + + shared = self.shared() - + if shared.ancestorof(self): + return True + + if shared.has_parent_from(self): + return True + + return False + def update(self, user): """Update parts of the document.""" lock = self.library.lock() @@ -117,78 +126,104 @@ class MercurialDocument(wlrepo.Document): if self.ismain(): # main revision of the document return self - - if self._revision.has_children(): - raise UpdateException("Revision has children.") - sv = self.shared() + # check for children in this branch + if self._revision.has_children(limit_branch=True): + raise wlrepo.UpdateException("Revision %s has children." % self.revision) - if self.parentof(sv): + shared = self.shared() + # * + # /| + # * | + # | | + # + # we carry the latest version + if shared.ancestorof(self): + return self + + # * + # |\ + # | * + # | | + # + # We just shared + if self.parentof(shared): return self - if sv.ancestorof(self): - return self + # s s S + # | | | + # *<-S *<-* + # | | | . + # + # This is ok (s - shared, S - self) - if self._revision.merge_with(sv._revision, user=user,\ + if self._revision.merge_with(shared._revision, user=user,\ message="$AUTO$ Personal branch update."): return self.latest() else: - raise UpdateException("Merge failed.") + raise wlrepo.UpdateException("Merge failed.") finally: - lock.release() + lock.release() + + + def would_share(self): + if self.ismain(): + return False, "Main version is always shared" + + shared = self.shared() + + # we just did this - move on + if self.parentof(shared): + return False, "Document has been recetly shared - no changes" + + # * + # /| + # * * + # |\| + # | * + # | | + # Situation above is ok - what we don't want, is: + # * + # /| + # * | + # |\| + # | * + # | | + # We want to prevent stuff like this. + if self.parent().parentof(shared): + return False, "Preventing zig-zag" + + return True, "OK" + def share(self, message): lock = self.library.lock() - try: - if self.ismain(): - return False # always shared - - user = self._revision.user_name - main = self.shared()._revision - local = self._revision + try: + result, info = self.would_share() - # Case 1: + if not result: + return self.shared() + + # The good situation + # # * local # | - # * <- can also be here! - # /| + # >* + # || # / | # main * * # | | - # The local branch has been recently updated, - # so we don't need to update yet again, but we need to - # merge down to default branch, even if there was - # no commit's since last update - # - # This is actually the only good case! - if main.ancestorof(local): - success, changed = main.merge_with(local, user=user, message=message) + shared = self.shared() - if not success: - raise LibraryException("Merge failed.") + if shared.ancestorof(self): + success = shared._revision.merge_with(self._revision, user=self.owner, message=message) - return changed - - # Case 2: - # main * - # | - # * <- this case overlaps with previos one - # |\ - # | \ - # | * local - # | | - # - # There was a recent merge to the defaul branch and - # no changes to local branch recently. - # - # Nothing to do - elif local.ancestorof(main): - return False + if not success: + raise wlrepo.LibraryException("Merge failed.") + + return shared.latest() - # In all other cases, the local needs an update - # and possibly conflict resolution, so fail - raise LibraryExcepton("Document not prepared for sharing.") - + raise wlrepo.LibraryException("Unrecognized share-state.") finally: lock.release()