/brz/remove-bazaar

# Copyright (C) 2005 Canonical Ltd

#

# This program is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, write to the Free Software

# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

# XXX: Can we do any better about making interrupted commits change

# nothing?  Perhaps the best approach is to integrate commit of

# AtomicFiles with releasing the lock on the Branch.

# TODO: Separate 'prepare' phase where we find a list of potentially

# committed files.  We then can then pause the commit to prompt for a

# commit message, knowing the summary will be the same as what's

# actually used for the commit.  (But perhaps simpler to simply get

# the tree status, then use that for a selective commit?)

# The newly committed revision is going to have a shape corresponding

# to that of the working inventory.  Files that are not in the

# working tree and that were in the predecessor are reported as

# removed --- this can include files that were either removed from the

# inventory or deleted in the working tree.  If they were only

# deleted from disk, they are removed from the working inventory.

# We then consider the remaining entries, which will be in the new

# version.  Directory entries are simply copied across.  File entries

# must be checked to see if a new version of the file should be

# recorded.  For each parent revision inventory, we check to see what

# version of the file was present.  If the file was present in at

# least one tree, and if it was the same version in all the trees,

# then we can just refer to that version.  Otherwise, a new version

# representing the merger of the file versions must be added.

# TODO: Update hashcache before and after - or does the WorkingTree

# look after that?

# This code requires all merge parents to be present in the branch.

# We could relax this but for the sake of simplicity the constraint is

# here for now.  It's not totally clear to me how we'd know which file

# need new text versions if some parents are absent.  -- mbp 20050915

import os

import sys

import time

import pdb

from binascii import hexlify

from cStringIO import StringIO

from bzrlib.osutils import (local_time_offset, username,

                            rand_bytes, compact_date, user_email,

                            kind_marker, is_inside_any, quotefn,

                            sha_string, sha_strings, sha_file, isdir, isfile,

                            split_lines)

from bzrlib.branch import gen_file_id, INVENTORY_FILEID, ANCESTRY_FILEID

from bzrlib.errors import (BzrError, PointlessCommit,

                           HistoryMissing,

                           )

from bzrlib.revision import Revision, RevisionReference

from bzrlib.trace import mutter, note, warning

from bzrlib.xml5 import serializer_v5

from bzrlib.inventory import Inventory

from bzrlib.weave import Weave

from bzrlib.weavefile import read_weave, write_weave_v5

from bzrlib.atomicfile import AtomicFile

def commit(*args, **kwargs):

    """Commit a new revision to a branch.

    Function-style interface for convenience of old callers.

    New code should use the Commit class instead.

    """

    ## XXX: Remove this in favor of Branch.commit?

    Commit().commit(*args, **kwargs)

class NullCommitReporter(object):

    """I report on progress of a commit."""

    def added(self, path):

        pass

    def removed(self, path):

        pass

    def renamed(self, old_path, new_path):

        pass

class ReportCommitToLog(NullCommitReporter):

    def added(self, path):

        note('added %s', path)

    def removed(self, path):

        note('removed %s', path)

    def renamed(self, old_path, new_path):

        note('renamed %s => %s', old_path, new_path)

class Commit(object):

    """Task of committing a new revision.

    This is a MethodObject: it accumulates state as the commit is

    prepared, and then it is discarded.  It doesn't represent

    historical revisions, just the act of recording a new one.

            missing_ids

            Modified to hold a list of files that have been deleted from

            the working directory; these should be removed from the

            working inventory.

    """

    def __init__(self,

                 reporter=None):

        if reporter is not None:

            self.reporter = reporter

        else:

            self.reporter = NullCommitReporter()

    def commit(self,

               branch, message,

               timestamp=None,

               timezone=None,

               committer=None,

               specific_files=None,

               rev_id=None,

               allow_pointless=True,

               verbose=False):

        """Commit working copy as a new revision.

        timestamp -- if not None, seconds-since-epoch for a

             postdated/predated commit.

        specific_files -- If true, commit only those files.

        rev_id -- If set, use this as the new revision id.

            Useful for test or import commands that need to tightly

            control what revisions are assigned.  If you duplicate

            a revision id that exists elsewhere it is your own fault.

            If null (default), a time/random revision id is generated.

        allow_pointless -- If true (default), commit even if nothing

            has changed and no merges are recorded.

        """

        mutter('preparing to commit')

        self.branch = branch

        self.weave_store = branch.weave_store

        self.rev_id = rev_id

        self.specific_files = specific_files

        self.allow_pointless = allow_pointless

        if timestamp is None:

            self.timestamp = time.time()

        else:

            self.timestamp = long(timestamp)

        if rev_id is None:

            self.rev_id = _gen_revision_id(self.branch, self.timestamp)

        else:

            self.rev_id = rev_id

        if committer is None:

            self.committer = username(self.branch)

        else:

            assert isinstance(committer, basestring), type(committer)

            self.committer = committer

        if timezone is None:

            self.timezone = local_time_offset()

        else:

            self.timezone = int(timezone)

        assert isinstance(message, basestring), type(message)

        self.message = message

        self.branch.lock_write()

        try:

            self.work_tree = self.branch.working_tree()

            self.work_inv = self.work_tree.inventory

            self.basis_tree = self.branch.basis_tree()

            self.basis_inv = self.basis_tree.inventory

            self._gather_parents()

            self._check_parents_present()

            self._remove_deleted()

            self.new_inv = Inventory()

            self._store_files()

            self._report_deletes()

            if not (self.allow_pointless

                    or len(self.parents) > 1

                    or self.new_inv != self.basis_inv):

                raise PointlessCommit()

            self._record_inventory()

            self._record_ancestry()

            self._make_revision()

            note('committed r%d {%s}', (self.branch.revno() + 1),

                 self.rev_id)

            self.branch.append_revision(self.rev_id)

            self.branch.set_pending_merges([])

        finally:

            self.branch.unlock()

    def _record_inventory(self):

        """Store the inventory for the new revision."""

        inv_text = serializer_v5.write_inventory_to_string(self.new_inv)

        self.inv_sha1 = sha_string(inv_text)

        self.weave_store.add_text(INVENTORY_FILEID, self.rev_id,

                                         split_lines(inv_text), self.parents)

    def _record_ancestry(self):

        """Append merged revision ancestry to the ancestry file.

        This should be the merged ancestry of all parents, plus the

        new revision id."""

        w = self.weave_store.get_weave_or_empty(ANCESTRY_FILEID)

        lines = self._merge_ancestry_lines(w)

        w.add(self.rev_id, self.parents, lines)

        self.weave_store.put_weave(ANCESTRY_FILEID, w)

    def _merge_ancestry_lines(self, ancestry_weave):

        """Return merged ancestry lines.

        The lines are revision-ids followed by newlines."""

        seen = set()

        ancs = []

        for parent_id in self.parents:

            for line in ancestry_weave.get(parent_id):

                assert line[-1] == '\n'

                if line not in seen:

                    ancs.append(line)

                    seen.add(line)

        r = self.rev_id + '\n'

        assert r not in ancs

        ancs.append(r)

        mutter('merged ancestry of {%s}:\n%s', self.rev_id, ''.join(ancs))

        return ancs

    def _gather_parents(self):

        pending_merges = self.branch.pending_merges()

        self.parents = []

        self.parent_trees = []

        precursor_id = self.branch.last_revision()

        if precursor_id:

            self.parents.append(precursor_id)

            self.parent_trees.append(self.basis_tree)

        self.parents += pending_merges

        self.parent_trees.extend(map(self.branch.revision_tree, pending_merges))

    def _check_parents_present(self):

        for parent_id in self.parents:

            mutter('commit parent revision {%s}', parent_id)

            if not self.branch.has_revision(parent_id):

                warning("can't commit a merge from an absent parent")

                raise HistoryMissing(self.branch, 'revision', parent_id)

    def _make_revision(self):

        """Record a new revision object for this commit."""

        self.rev = Revision(timestamp=self.timestamp,

                            timezone=self.timezone,

                            committer=self.committer,

                            message=self.message,

                            inventory_sha1=self.inv_sha1,

                            revision_id=self.rev_id)

        self.rev.parents = map(RevisionReference, self.parents)

        rev_tmp = StringIO()

        serializer_v5.write_revision(self.rev, rev_tmp)

        rev_tmp.seek(0)

        self.branch.revision_store.add(rev_tmp, self.rev_id)

        mutter('new revision_id is {%s}', self.rev_id)

    def _remove_deleted(self):

        """Remove deleted files from the working inventories.

        This is done prior to taking the working inventory as the

        basis for the new committed inventory.

        This returns true if any files

        *that existed in the basis inventory* were deleted.

        Files that were added and deleted

        in the working copy don't matter.

        """

        specific = self.specific_files

        deleted_ids = []

        for path, ie in self.work_inv.iter_entries():

            if specific and not is_inside_any(specific, path):

                continue

            if not self.work_tree.has_filename(path):

                note('missing %s', path)

                deleted_ids.append(ie.file_id)

        if deleted_ids:

            for file_id in deleted_ids:

                del self.work_inv[file_id]

            self.branch._write_inventory(self.work_inv)

    def _find_file_parents(self, file_id):

        """Return the text versions and hashes for all file parents.

        Returned as a map from text version to inventory entry.

        This is a set containing the file versions in all parents

        revisions containing the file.  If the file is new, the set

        will be empty."""

        r = {}

        for tree in self.parent_trees:

            if file_id in tree.inventory:

                ie = tree.inventory[file_id]

                assert ie.kind == 'file'

                assert ie.file_id == file_id

                if ie.text_version in r:

                    assert r[ie.text_version] == ie

                else:

                    r[ie.text_version] = ie

        return r            

    def _store_files(self):

        """Store new texts of modified/added files.

        This is called with new_inv set to a copy of the working

        inventory, with deleted/removed files already cut out.  So

        this code only needs to deal with setting text versions, and

        possibly recording new file texts."""

        for path, new_ie in self.work_inv.iter_entries():

            file_id = new_ie.file_id

            mutter('check %s {%s}', path, new_ie.file_id)

            if self.specific_files:

                if not is_inside_any(self.specific_files, path):

                    mutter('%s not selected for commit', path)

                    self._carry_file(file_id)

                    continue

            if new_ie.kind != 'file':

                self._commit_nonfile(file_id)

                continue

            file_parents = self._find_file_parents(file_id)

            if len(file_parents) == 1:

                parent_ie = file_parents.values()[0]

                wc_sha1 = self.work_tree.get_file_sha1(file_id)

                if parent_ie.text_sha1 == wc_sha1:

                    # text not changed or merged

                    self._commit_old_text(file_id, parent_ie)

                    continue

            mutter('parents of %s are %r', path, file_parents)

            # file is either new, or a file merge; need to record

            # a new version

            if len(file_parents) > 1:

                note('merged %s', path)

            elif len(file_parents) == 0:

                note('added %s', path)

            else:

                note('modified %s', path)

            self._commit_file(new_ie, file_id, file_parents)

    def _commit_nonfile(self, file_id):

        self.new_inv.add(self.work_inv[file_id].copy())

    def _carry_file(self, file_id):

        """Carry the file unchanged from the basis revision."""

        if self.basis_inv.has_id(file_id):

            self.new_inv.add(self.basis_inv[file_id].copy())

    def _commit_old_text(self, file_id, parent_ie):

        """Keep the same text as last time, but possibly a different name."""

        ie = self.work_inv[file_id].copy()

        ie.text_version = parent_ie.text_version

        ie.text_size = parent_ie.text_size

        ie.text_sha1 = parent_ie.text_sha1

        self.new_inv.add(ie)

    def _report_deletes(self):

        for file_id in self.basis_inv:

            if file_id not in self.new_inv:

                note('deleted %s', self.basis_inv.id2path(file_id))

    def _commit_file(self, new_ie, file_id, file_parents):                    

        mutter('store new text for {%s} in revision {%s}',

               file_id, self.rev_id)

        new_lines = self.work_tree.get_file(file_id).readlines()

        self._add_text_to_weave(file_id, new_lines, file_parents)

        new_ie.text_version = self.rev_id

        new_ie.text_sha1 = sha_strings(new_lines)

        new_ie.text_size = sum(map(len, new_lines))

        self.new_inv.add(new_ie)

    def _add_text_to_weave(self, file_id, new_lines, parents):

        if file_id.startswith('__'):

            raise ValueError('illegal file-id %r for text file' % file_id)

        self.weave_store.add_text(file_id, self.rev_id, new_lines, parents)

def _gen_revision_id(branch, when):

    """Return new revision-id."""

    s = '%s-%s-' % (user_email(branch), compact_date(when))

    s += hexlify(rand_bytes(8))

    return s