Merge lp:~abentley/wikkid/branch-file-store into lp:wikkid

[Aaron Bentley]

A branch-backed file store. Certain things were refactored for reuse.

Commits are performed on the branch directly, by using a TransformPreview.

Win!

[Tim Penhey (thumper)]

Awesome, merging.

review: Approve

=== modified file 'wikkid/filestore/bzr.py'
--- wikkid/filestore/bzr.py	2010-10-17 01:47:00 +0000
+++ wikkid/filestore/bzr.py	2011-06-30 16:12:03 +0000
@@ -11,11 +11,12 @@
 
 from zope.interface import implements
 
-from bzrlib.errors import BinaryFile
+from bzrlib.errors import BinaryFile, MalformedTransform
 from bzrlib.merge3 import Merge3
-from bzrlib.osutils import split_lines
+from bzrlib.osutils import splitpath, split_lines
 from bzrlib.revision import NULL_REVISION
-from bzrlib.textfile import check_text_path
+from bzrlib.textfile import check_text_lines
+from bzrlib.transform import FinalPaths, TransformPreview
 from bzrlib.urlutils import basename, dirname, joinpath
 
 from wikkid.errors import FileExists, UpdateConflicts
@@ -38,18 +39,61 @@
     return '\n'
 
 
+def get_commit_message(commit_message):
+    if commit_message is None or commit_message.strip() == '':
+        return 'No description of change given.'
+    return commit_message
+
+
+def normalize_content(content):
+    # Default to simple '\n' line endings.
+    content = normalize_line_endings(content)
+    # Make sure the content ends with a new-line.  This makes
+    # end of file conflicts nicer.
+    if not content.endswith('\n'):
+        content += '\n'
+    return content
+
+
+def iter_paths(path):
+    path_segments = splitpath(path)
+    while len(path_segments) > 0:
+        tail = path_segments.pop()
+        if len(path_segments) == 0:
+            yield '', tail
+        else:
+            yield joinpath(*path_segments), tail
+
+
+def create_parents(tt, path, trans_id):
+    prev_trans_id = trans_id
+    for parent_path, tail in iter_paths(path):
+        trans_id = tt.trans_id_tree_path(parent_path)
+        tt.adjust_path(tail, trans_id, prev_trans_id)
+        if tt.tree_kind(trans_id) is not None:
+            break
+        tt.create_directory(trans_id)
+        tt.version_file(trans_id, trans_id)
+        prev_name = tail
+        prev_trans_id = trans_id
+
+
 class FileStore(object):
     """Wraps a Bazaar branch to be a filestore."""
 
     implements(IFileStore)
 
-    def __init__(self, working_tree):
-        self.working_tree = working_tree
+    def __init__(self, tree):
+        self.tree = tree
+        self.branch = tree.branch
         self.logger = logging.getLogger('wikkid')
 
+    def basis_tree(self):
+        return self.tree.basis_tree()
+
     def get_file(self, path):
         """Return an object representing the file at specified path."""
-        file_id = self.working_tree.path2id(path)
+        file_id = self.tree.path2id(path)
         if file_id is None:
             return None
         else:
@@ -62,16 +106,15 @@
         This is going to be really interesting when we need to deal with
         conflicts.
         """
-        if commit_message is None or commit_message.strip() == '':
-            commit_message = 'No description of change given.'
+        commit_message = get_commit_message(commit_message)
         if parent_revision is None:
             parent_revision = NULL_REVISION
         # Firstly we want to lock the tree for writing.
-        self.working_tree.lock_write()
+        self.tree.lock_write()
         try:
             # Look to see if the path is there.  If it is then we are doing an
             # update.  If it isn't we are doing an add.
-            file_id = self.working_tree.path2id(path)
+            file_id = self.tree.path2id(path)
             if file_id is None:
                 self._add_file(path, content, author, commit_message)
             else:
@@ -80,7 +123,7 @@
                     file_id, path, content, author, parent_revision,
                     commit_message)
         finally:
-            self.working_tree.unlock()
+            self.tree.unlock()
 
     def _ensure_directory_or_nonexistant(self, dir_path):
         """Ensure the dir_path defines a directory or doesn't exist.
@@ -106,13 +149,8 @@
 
         Then commit this new file with the specified commit_message.
         """
-        # Default to simple '\n' line endings.
-        content = normalize_line_endings(content)
-        # Make sure the content ends with a new-line.  This makes
-        # end of file conflicts nicer.
-        if not content.endswith('\n'):
-            content += '\n'
-        t = self.working_tree.bzrdir.root_transport
+        content = normalize_content(content)
+        t = self.tree.bzrdir.root_transport
         # Get a transport for the path we want.
         self._ensure_directory_or_nonexistant(dirname(path))
         t = t.clone(dirname(path))
@@ -120,11 +158,37 @@
         # Put the file there.
         # TODO: UTF-8 encode text files?
         t.put_bytes(basename(path), content)
-        self.working_tree.smart_add([t.local_abspath('.')])
-        self.working_tree.commit(
+        self.tree.smart_add([t.local_abspath('.')])
+        self.tree.commit(
             message=commit_message,
             authors=[author])
 
+    def _get_final_text(self, content, f, parent_revision):
+        current_rev = f.last_modified_in_revision
+        wt = self.tree
+        current_lines = wt.get_file_lines(f.file_id)
+        basis = self.branch.repository.revision_tree(parent_revision)
+        basis_lines = basis.get_file_lines(f.file_id)
+        # need to break content into lines.
+        ending = get_line_ending(current_lines)
+        # If the content doesn't end with a new line, add one.
+        new_lines = split_lines(content)
+        # Look at the end of the first string.
+        new_ending = get_line_ending(new_lines)
+        if ending != new_ending:
+            # I know this is horribly inefficient, but lets get it working
+            # first.
+            content = normalize_line_endings(content, ending)
+            new_lines = split_lines(content)
+        if len(new_lines) > 0 and not new_lines[-1].endswith(ending):
+            new_lines[-1] += ending
+        merge = Merge3(basis_lines, new_lines, current_lines)
+        result = list(merge.merge_lines()) # or merge_regions or whatever
+        conflicted = ('>>>>>>>' + ending) in result
+        if conflicted:
+            raise UpdateConflicts(''.join(result), current_rev)
+        return result
+
     def _update_file(self, file_id, path, content, author, parent_revision,
                      commit_message):
         """Update an existing file with the content.
@@ -132,36 +196,14 @@
         This method merges the changes in based on the parent revision.
         """
         f = File(self, path, file_id)
-        current_rev = f.last_modified_in_revision
-        wt = self.working_tree
+        wt = self.tree
         wt.lock_write()
         try:
-            current_lines = wt.get_file_lines(file_id)
-            basis = wt.branch.repository.revision_tree(parent_revision)
-            basis_lines = basis.get_file_lines(file_id)
-            # need to break content into lines.
-            ending = get_line_ending(current_lines)
-            # If the content doesn't end with a new line, add one.
-            new_lines = split_lines(content)
-            # Look at the end of the first string.
-            new_ending = get_line_ending(new_lines)
-            if ending != new_ending:
-                # I know this is horribly inefficient, but lets get it working
-                # first.
-                content = normalize_line_endings(content, ending)
-                new_lines = split_lines(content)
-            if len(new_lines) > 0 and not new_lines[-1].endswith(ending):
-                new_lines[-1] += ending
-            merge = Merge3(basis_lines, new_lines, current_lines)
-            result = list(merge.merge_lines()) # or merge_regions or whatever
-            conflicted = ('>>>>>>>' + ending) in result
-            if conflicted:
-                raise UpdateConflicts(''.join(result), current_rev)
-            else:
-                wt.bzrdir.root_transport.put_bytes(path, ''.join(result))
-                wt.commit(
-                    message=commit_message, authors=[author],
-                    specific_files=[path])
+            result = self._get_final_text(content, f, parent_revision)
+            wt.bzrdir.root_transport.put_bytes(path, ''.join(result))
+            wt.commit(
+                message=commit_message, authors=[author],
+                specific_files=[path])
         finally:
             wt.unlock()
 
@@ -177,7 +219,7 @@
             if directory is None or directory.file_type != FileType.DIRECTORY:
                 return None
         listing = []
-        wt = self.working_tree
+        wt = self.tree
         wt.lock_read()
         try:
             for fp, fc, fkind, fid, entry in wt.list_files(
@@ -204,9 +246,9 @@
         BaseFile.__init__(self, path, file_id)
         self.filestore = filestore
         # This isn't entirely necessary.
-        self.working_tree = self.filestore.working_tree
+        self.tree = self.filestore.tree
         self.file_type = self._get_filetype()
-        bt = self.working_tree.basis_tree()
+        bt = self.filestore.basis_tree()
         bt.lock_read()
         try:
             inv_file = bt.inventory[self.file_id]
@@ -216,7 +258,7 @@
 
     def _get_filetype(self):
         """Work out the filetype based on the mimetype if possible."""
-        is_directory = ('directory' == self.working_tree.kind(self.file_id))
+        is_directory = ('directory' == self.tree.kind(self.file_id))
         if is_directory:
             return FileType.DIRECTORY
         else:
@@ -232,27 +274,27 @@
     def get_content(self):
         if self.file_id is None:
             return None
-        self.working_tree.lock_read()
+        self.tree.lock_read()
         try:
             # basis_tree is a revision tree, queries the repositry.
             # to get the stuff off the filesystem use the working tree
             # which needs to start with that.  WorkingTree.open('.').
             # branch = tree.branch.
-            return self.working_tree.get_file_text(self.file_id)
+            return self.tree.get_file_text(self.file_id)
         finally:
-            self.working_tree.unlock()
+            self.tree.unlock()
 
     @property
     def last_modified_by(self):
         """Return the first author for the revision."""
-        repo = self.working_tree.branch.repository
+        repo = self.filestore.branch.repository
         rev = repo.get_revision(self.last_modified_in_revision)
         return rev.get_apparent_authors()[0]
 
     @property
     def last_modified_date(self):
         """Return the last modified date for the revision."""
-        repo = self.working_tree.branch.repository
+        repo = self.filestore.branch.repository
         rev = repo.get_revision(self.last_modified_in_revision)
         return datetime.utcfromtimestamp(rev.timestamp)
 
@@ -260,7 +302,12 @@
     def _is_binary(self):
         """True if the file is binary."""
         try:
-            check_text_path(self.working_tree.abspath(self.path))
+            self.tree.lock_read()
+            try:
+                lines = self.tree.get_file_lines(self.file_id)
+                check_text_lines(lines)
+            finally:
+                self.tree.unlock()
             return False
         except BinaryFile:
             return True
@@ -268,7 +315,53 @@
     @property
     def is_directory(self):
         """Is this file a directory?"""
-        return 'directory' == self.working_tree.kind(self.file_id)
+        return 'directory' == self.tree.kind(self.file_id)
 
     def update(self, content, user):
         raise NotImplementedError()
+
+
+class BranchFileStore(FileStore):
+
+    def __init__(self, branch):
+        self.branch = branch
+        self.tree = branch.basis_tree()
+        self.logger = logging.getLogger('wikkid')
+
+    def basis_tree(self):
+        return self.tree
+
+    def update_file(self, path, content, author, parent_revision,
+                    commit_message=None):
+        commit_message = get_commit_message(commit_message)
+        self.branch.lock_write()
+        try:
+            file_id = self.tree.path2id(path)
+            if file_id is not None:
+                f = File(self, path, file_id)
+                content = self._get_final_text(content, f, parent_revision)
+            else:
+                content = normalize_content(content)
+
+            with TransformPreview(self.tree) as tt:
+                trans_id = tt.trans_id_tree_path(path)
+                if tt.tree_kind(trans_id) is not None:
+                    tt.delete_contents(trans_id)
+                else:
+                    tt.version_file(trans_id, trans_id)
+                    create_parents(tt, path, trans_id)
+                tt.create_file(content, trans_id)
+                try:
+                    tt.commit(self.branch, commit_message, authors=[author])
+                except MalformedTransform, e:
+                    for conflict in e.conflicts:
+                        if conflict[0] == 'non-directory parent':
+                            path = FinalPaths(tt).get_path(trans_id)
+                            raise FileExists(
+                                '%s exists and is not a directory' %
+                                conflict[1])
+                    raise
+
+            self.tree = self.branch.basis_tree()
+        finally:
+            self.branch.unlock()
 
=== modified file 'wikkid/tests/test_bzr_filestore.py'
--- wikkid/tests/test_bzr_filestore.py	2010-10-17 21:04:36 +0000
+++ wikkid/tests/test_bzr_filestore.py	2011-06-30 16:12:03 +0000
@@ -11,7 +11,10 @@
 from bzrlib.tests import TestCaseWithTransport
 
 from wikkid.errors import UpdateConflicts
-from wikkid.filestore.bzr import FileStore
+from wikkid.filestore.bzr import (
+    BranchFileStore,
+    FileStore,
+    )
 from wikkid.tests import ProvidesMixin
 from wikkid.tests.filestore import TestFileStore
 
@@ -134,3 +137,14 @@
             'test.txt', '', 'Test Author <[e-mail]>', base_rev)
         curr = filestore.get_file('test.txt')
         self.assertEqual('', curr.get_content())
+
+
+class TestBranchFileStore(TestBzrFileStore):
+
+    def make_filestore(self, contents=None):
+        tree = self.make_branch_and_tree('.')
+        if contents:
+            self.build_tree_contents(contents)
+        tree.smart_add(['.'])
+        tree.commit(message='Initial commit', authors=['[e-mail]'])
+        return BranchFileStore(tree.branch)