/brz/remove-bazaar

#!/usr/bin/env python

"""\

Just some work for generating a changeset.

"""

import bzrlib, bzrlib.errors

import common

from bzrlib.inventory import ROOT_ID

try:

    set

except NameError:

    from sets import Set as set

def _get_trees(branch, revisions):

    """Get the old and new trees based on revision.

    """

    from bzrlib.tree import EmptyTree

    if revisions[0] is None:

        if hasattr(branch, 'get_root_id'): # Watch out for trees with labeled ROOT ids

            old_tree = EmptyTree(branch.get_root_id) 

        else:

            old_tree = EmptyTree()

    else:

        old_tree = branch.revision_tree(revisions[0])

    if revisions[1] is None:

        raise BzrCommandError('Cannot form a bzr changeset with no committed revisions')

    else:

        new_tree = branch.revision_tree(revisions[1])

    return old_tree, new_tree

def _fake_working_revision(branch):

    """Fake a Revision object for the working tree.

    This is for the future, to support changesets against the working tree.

    """

    from bzrlib.revision import Revision

    import time

    from bzrlib.osutils import local_time_offset, \

            username

    precursor = branch.last_patch()

    precursor_sha1 = branch.get_revision_sha1(precursor)

    return Revision(timestamp=time.time(),

            timezone=local_time_offset(),

            committer=username(),

            precursor=precursor,

            precursor_sha1=precursor_sha1)

class MetaInfoHeader(object):

    """Maintain all of the header information about this

    changeset.

    """

    def __init__(self, branch, revisions, delta,

            full_remove=True, full_rename=False,

            new_tree=None, old_tree=None,

            old_label = '', new_label = ''):

        """

        :param full_remove: Include the full-text for a delete

        :param full_rename: Include an add+delete patch for a rename

        """

        self.branch = branch

        self.delta = delta

        self.full_remove=full_remove

        self.full_rename=full_rename

        self.old_label = old_label

        self.new_label = new_label

        self.old_tree = old_tree

        self.new_tree = new_tree

        self.to_file = None

        #self.revno = None

        #self.parent_revno = None

        # These are entries in the header.

        # They will be repeated in the footer,

        # only if they have changed

        self.date = None

        self.committer = None

        self.message = None

        self._get_revision_list(revisions)

    def _get_revision_list(self, revisions):

        """This generates the list of all revisions from->to.

        This is for having a rollup changeset.

        """

        old_revno = None

        new_revno = None

        rh = self.branch.revision_history()

        for revno, rev in enumerate(rh):

            if rev == revisions[0]:

                old_revno = revno

            if rev == revisions[1]:

                new_revno = revno

        self.revision_list = []

        if old_revno is None:

            self.base_revision = None # Effectively the EmptyTree()

            old_revno = -1

        else:

            self.base_revision = self.branch.get_revision(rh[old_revno])

        if new_revno is None:

            # For the future, when we support working tree changesets.

            for rev_id in rh[old_revno+1:]:

                self.revision_list.append(self.branch.get_revision(rev_id))

            self.revision_list.append(_fake_working_revision(self.branch))

        else:

            for rev_id in rh[old_revno+1:new_revno+1]:

                self.revision_list.append(self.branch.get_revision(rev_id))

        #self.parent_revno = old_revno+1

        #self.revno = new_revno+1

    def _write(self, txt, key=None):

        if key:

            self.to_file.write('# %s: %s\n' % (key, txt))

        else:

            self.to_file.write('# %s\n' % (txt,))

    def write_meta_info(self, to_file):

        """Write out the meta-info portion to the supplied file.

        :param to_file: Write out the meta information to the supplied

                        file

        """

        self.to_file = to_file

        self._write_header()

        self._write_diffs()

        self._write_footer()

    def _write_header(self):

        """Write the stuff that comes before the patches."""

        from bzrlib.osutils import username

        from common import format_highres_date

        write = self._write

        for line in common.get_header():

            write(line)

        # Print out the basic information about the 'target' revision

        rev = self.revision_list[-1]

        write(rev.committer, key='committer')

        self.committer = rev.committer

        self.date = format_highres_date(rev.timestamp, offset=rev.timezone)

        write(self.date, key='date')

        if rev.message:

            self.to_file.write('# message:\n')

            for line in rev.message.split('\n'):

                self.to_file.write('#    %s\n' % line)

            self.message = rev.message

        write('')

        self.to_file.write('\n')

    def _write_footer(self):

        """Write the stuff that comes after the patches.

        This is meant to be more meta-information, which people probably don't want

        to read, but which is required for proper bzr operation.

        """

        write = self._write

        # What should we print out for an Empty base revision?

        assumed_base = self.revision_list[0].parents[0].revision_id

        if self.base_revision.revision_id != assumed_base:

            base = self.base_revision.revision_id

            write(base, key='base')

            write(self.branch.get_revision_sha1(base), key='base sha1')

        self._write_revisions()

        #self._write_ids()

        self._write_text_ids()

    def _write_revisions(self):

        """Not used. Used for writing multiple revisions."""

        from common import format_highres_date

        for rev in self.revision_list:

            rev_id = rev.revision_id

            self.to_file.write('# revision: %s\n' % rev_id)

            self.to_file.write('#    sha1: %s\n' % 

                self.branch.get_revision_sha1(rev_id))

            if rev.committer != self.committer:

                self.to_file.write('#    committer: %s\n' % rev.committer)

            date = format_highres_date(rev.timestamp, rev.timezone)

            if date != self.date:

                self.to_file.write('#    date: %s\n' % date)

            if rev.inventory_id != rev_id:

                self.to_file.write('#    inventory id: %s\n' % rev.inventory_id)

            self.to_file.write('#    inventory sha1: %s\n' % rev.inventory_sha1)

            self.to_file.write('#    parents:\n')

            for parent in rev.parents:

                self.to_file.write('#       %s\t%s\n' % (

                    parent.revision_id,

                    parent.revision_sha1))

            if rev.message and rev.message != self.message:

                self.to_file.write('#    message:\n')

                for line in rev.message.split('\n'):

                    self.to_file.write('#       %s\n' % line)

    def _write_ids(self):

        if hasattr(self.branch, 'get_root_id'):

            root_id = self.branch.get_root_id()

        else:

            root_id = ROOT_ID

        old_ids = set()

        new_ids = set()

        for path, file_id, kind in self.delta.removed:

            old_ids.add(file_id)

        for path, file_id, kind in self.delta.added:

            new_ids.add(file_id)

        for old_path, new_path, file_id, kind, text_modified in self.delta.renamed:

            old_ids.add(file_id)

            new_ids.add(file_id)

        for path, file_id, kind in self.delta.modified:

            new_ids.add(file_id)

        self._write(root_id, key='tree root id')

        def write_ids(tree, id_set, name):

            if len(id_set) > 0:

                self.to_file.write('# %s ids:\n' % name)

            seen_ids = set([root_id])

            while len(id_set) > 0:

                file_id = id_set.pop()

                if file_id in seen_ids:

                    continue

                seen_ids.add(file_id)

                ie = tree.inventory[file_id]

                if ie.parent_id not in seen_ids:

                    id_set.add(ie.parent_id)

                path = tree.inventory.id2path(file_id)

                self.to_file.write('#    %s\t%s\t%s\n'

                        % (path, file_id,

                            ie.parent_id))

        write_ids(self.new_tree, new_ids, 'file')

        write_ids(self.old_tree, old_ids, 'old file')

    def _write_text_ids(self):

        pass

    def _write_diffs(self):

        """Write out the specific diffs"""

        from bzrlib.diff import internal_diff, external_diff

        from common import encode

        DEVNULL = '/dev/null'

        diff_file = internal_diff

        # Get the target tree so that we can check for

        # Appropriate text ids.

        rev_id = self.revision_list[-1].revision_id

        tree = self.branch.revision_tree(rev_id)

        def get_text_id_str(file_id, modified=True):

            """This returns an empty string if guess_text_id == real_text_id.

            Otherwise it returns a string suitable for printing, indicating

            the file's id.

            """

            guess_id = common.guess_text_id(tree, file_id, rev_id,

                    modified=modified)

            real_id = tree.inventory[file_id].text_id

            if guess_id != real_id:

                return '\ttext-id:' + encode(real_id)

            else:

                return ''

        for path, file_id, kind in self.delta.removed:

            # We don't care about text ids for removed files

            print >>self.to_file, '*** removed %s %s' % (kind,

                    encode(path))

            if kind == 'file' and self.full_remove:

                diff_file(self.old_label + path,

                          self.old_tree.get_file(file_id).readlines(),

                          DEVNULL, 

                          [],

                          self.to_file)

        for path, file_id, kind in self.delta.added:

            print >>self.to_file, '*** added %s %s\tfile-id:%s%s' % (kind,

                    encode(path),

                    encode(file_id),

                    get_text_id_str(file_id))

            if kind == 'file':

                diff_file(DEVNULL,

                          [],

                          self.new_label + path,

                          self.new_tree.get_file(file_id).readlines(),

                          self.to_file)

        for old_path, new_path, file_id, kind, text_modified in self.delta.renamed:

            print >>self.to_file, '*** renamed %s %s\t=> %s%s' % (kind,

                    encode(old_path), encode(new_path),

                    get_text_id_str(file_id, text_modified))

            if self.full_rename and kind == 'file':

                diff_file(self.old_label + old_path,

                          self.old_tree.get_file(file_id).readlines(),

                          DEVNULL, 

                          [],

                          self.to_file)

                diff_file(DEVNULL,

                          [],

                          self.new_label + new_path,

                          self.new_tree.get_file(file_id).readlines(),

                          self.to_file)

            elif text_modified:

                    diff_file(self.old_label + old_path,

                              self.old_tree.get_file(file_id).readlines(),

                              self.new_label + new_path,

                              self.new_tree.get_file(file_id).readlines(),

                              self.to_file)

        for path, file_id, kind in self.delta.modified:

            print >>self.to_file, '*** modified %s %s%s' % (kind,

                    encode(path), get_text_id_str(file_id))

            if kind == 'file':

                diff_file(self.old_label + path,

                          self.old_tree.get_file(file_id).readlines(),

                          self.new_label + path,

                          self.new_tree.get_file(file_id).readlines(),

                          self.to_file)

def show_changeset(branch, revisions=None, to_file=None, include_full_diff=False):

    from bzrlib.diff import compare_trees

    if to_file is None:

        import sys

        to_file = sys.stdout

    revisions = common.canonicalize_revision(branch, revisions)

    old_tree, new_tree = _get_trees(branch, revisions)

    delta = compare_trees(old_tree, new_tree, want_unchanged=False)

    meta = MetaInfoHeader(branch, revisions, delta,

            old_tree=old_tree, new_tree=new_tree)

    meta.write_meta_info(to_file)