X-Git-Url: https://git.mdrn.pl/redakcja.git/blobdiff_plain/e3daf6a78b558bb2d776b389ba65a58eea1de2be..51d914bc0007135058a61623a2d057d2a7626a28:/lib/wlrepo/__init__.py diff --git a/lib/wlrepo/__init__.py b/lib/wlrepo/__init__.py index 210322d0..ab6f319f 100644 --- a/lib/wlrepo/__init__.py +++ b/lib/wlrepo/__init__.py @@ -1,7 +1,6 @@ # -*- encoding: utf-8 -*- __author__="Łukasz Rekucki" __date__ ="$2009-09-18 10:49:24$" - __doc__ = """Main module for the Repository Abstraction Layer""" class Library(object): @@ -9,140 +8,121 @@ class Library(object): def __init__(self, create=False): """Open an existing library, or create a new one. By default, fails if the library doesn't exist.""" - self.create = create - - def main_cabinet(self): - """Return the "main" cabinet of the library.""" + self.create = create + + def documents(self): + """List all documents in the library.""" pass - def cabinets(self): - """List all cabinets in the library.""" + def document_for_rev(self, rev): + """Retrieve a document in the specified revision.""" pass - def cabinet(self, document, user, create=False): - """Open a cabinet belonging to the _user_ for a given _document_. - If the _document_ is actually a sub-document, it's parent's cabinet is - opened istead. - - If the cabinet doesn't exists and create is False (the default), a - CabinetNotFound exception is raised. - - If create is True, a new cabinet is created if it doesn't exist yet.""" + def document(self, docid, user=None): + """Retrieve a document from a library.""" pass + def get_revision(self, revid): + """Retrieve a handle to a specified revision.""" + return None -class Cabinet(object): + def document_create(self, docid): + """Create a new document. The document will have it's own branch.""" + - def __init__(self, library, name=None, doc=None, user=None): +class Document(object): + """A class representing a document package boundled with a revision.""" + + def __init__(self, library, revision): + """_library_ should be an instance of a Library.""" self._library = library - if name: - self._name = name - self._maindoc = '' - self._user = self._document = None - elif doc and user: - self._user = user - self._document = doc - self._name = user + ':' + doc - self._maindoc = doc + if isinstance(revision, Revision): + self._revision = revision else: - raise ValueError("You must provide either name or doc and user.") - - print "new cab:", self._name, self._user, self._document + self._revision = library.get_revision(revision) - @property - def username(self): - return self._user - - def __str__(self): - return "Cabinet(%s)" % self._name - - def documents(self): - """Lists all documents and sub-documents in this cabinet.""" - pass - - def retrieve(self, parts=None, shelve=None): - """Retrieve a document from a given shelve in the cabinet. If no - part is given, the main document is retrieved. If no shelve is given, - the top-most shelve is used. - If parts is a list, all the given parts are retrieved atomicly. Use None - as the name for the main document""" + def take(self, user): + """Make a user copy of the document. This is persistant.""" pass - def create(self, name, initial_data=''): - """Create a new sub-document in the cabinet with the given name.""" + def giveback(self): + """Informs the library, that the user no longer needs this document. + Should be called on the user version of document. If not, it doesn nothing.""" + + def data(self, entry): + """Returns the specified entry as a file-like object.""" pass - @property - def maindoc_name(self): - return self._maindoc - @property def library(self): return self._library @property - def name(self): - return self._name + def revision(self): + return self._revision - def shelf(self, selector=None): - pass + @property + def id(self): + return self._revision.document_name -class Document(object): - def __init__(self, cabinet, name): - self._cabinet = cabinet - self._name = name + @property + def owner(self): + return self._revision.user_name + + def parentof(self, other): + return self._revision.parentof(other._revision) - def read(self): - pass + def ancestorof(self, other): + return self._revision.ancestorof(other._revision) - def write(self, data): - pass - @property - def cabinet(self): - return self._cabinet +class Revision(object): - @property - def library(self): - return self._cabinet.library + def __init__(self, lib): + self._library = lib - @property - def name(self): - return self._name + def parentof(self, other): + return False - def shelf(self): - return self._cabinet.shelf() + def ancestorof(self, other): + return False @property - def size(self): - raise NotImplemented() + def document_name(self): + raise ValueError() @property - def parts(self): - raise NotImplemented() + def user_name(self): + raise ValueError() - -class Shelf(object): - - def __init__(self, lib): - self._library = lib - # # Exception classes # -class LibraryException(Exception): - +class LibraryException(Exception): def __init__(self, msg, cause=None): Exception.__init__(self, msg) self.cause = cause -class CabinetNotFound(LibraryException): - def __init__(self, cabname): - LibraryException.__init__(self, "Cabinet '%s' not found." % cabname) - pass +class RevisionNotFound(LibraryException): + def __init__(self, rev): + LibraryException.__init__(self, "Revision %r not found." % rev) + +class EntryNotFound(LibraryException): + def __init__(self, rev, entry, guesses=[]): + LibraryException.__init__(self, \ + u"Entry '%s' at revision %r not found. %s" % (entry, rev, \ + (u"Posible values:\n" + u',\n'.join(guesses)) if len(guesses) else u'') ) +class DocumentAlreadyExists(LibraryException): + pass # import backends to local namespace -from backend_mercurial import MercurialLibrary \ No newline at end of file + +def open_library(path, proto, *args, **kwargs): + if proto == 'hg': + import wlrepo.mercurial_backend + return wlrepo.mercurial_backend.MercurialLibrary(path, *args, **kwargs) + + raise NotImplemented() \ No newline at end of file