← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/commands.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2008-10-16 21:31:35 UTC
  • mfrom: (3363.19.4 fix-iter-changes)
  • Revision ID: pqm@pqm.ubuntu.com-20081016213135-0115pw9c95l2dyxq
PreviewTree.iter_changes accepts all standard parameters (abentley)

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/bundle/commands.py
1
 
#!/usr/bin/env python
 
1
# Copyright (C) 2006 Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
2
16
"""\
3
17
This is an attempt to take the internal delta object, and represent
4
18
it as a single-file text-only changeset.
7
21
"""
8
22
 
9
23
import sys
10
 
 
11
 
from bzrlib.branch import Branch
12
 
from bzrlib.commands import Command, register_command
13
 
import bzrlib.errors as errors
 
24
from cStringIO import StringIO
 
25
 
 
26
from bzrlib.lazy_import import lazy_import
 
27
lazy_import(globals(), """
 
28
from bzrlib import (
 
29
    branch,
 
30
    errors,
 
31
    merge_directive,
 
32
    revision as _mod_revision,
 
33
    urlutils,
 
34
    transport,
 
35
    )
 
36
""")
 
37
 
 
38
from bzrlib.commands import Command
14
39
from bzrlib.option import Option
15
 
from bzrlib.revision import (common_ancestor, MultipleRevisionSources,
16
 
                             NULL_REVISION)
17
 
from bzrlib.revisionspec import RevisionSpec
18
 
 
19
 
 
20
 
class cmd_send_changeset(Command):
21
 
    """Send a bundled up changset via mail.
22
 
 
23
 
    If no revision has been specified, the last commited change will
24
 
    be sent.
25
 
 
26
 
    Subject of the mail can be specified by the --message option,
27
 
    otherwise information from the changeset log will be used.
28
 
 
29
 
    A editor will be spawned where the user may enter a description
30
 
    of the changeset.  The description can be read from a file with
31
 
    the --file FILE option.
32
 
    """
33
 
    takes_options = ['revision', 'message', 'file']
34
 
    takes_args = ['to?']
35
 
 
36
 
    def run(self, to=None, message=None, revision=None, file=None):
37
 
        from bzrlib.errors import BzrCommandError
38
 
        from send_changeset import send_changeset
39
 
        
40
 
        if isinstance(revision, (list, tuple)):
41
 
            if len(revision) > 1:
42
 
                raise BzrCommandError('We do not support rollup-changesets yet.')
43
 
            revision = revision[0]
44
 
 
45
 
        b = Branch.open_containing('.')
46
 
 
47
 
        if not to:
48
 
            try:
49
 
                to = b.controlfile('x-send-address', 'rb').read().strip('\n')
50
 
            except:
51
 
                raise BzrCommandError('destination address is not known')
52
 
 
53
 
        if not isinstance(revision, (list, tuple)):
54
 
            revision = [revision]
55
 
 
56
 
        send_changeset(b, revision, to, message, file)
57
 
 
58
 
 
59
 
class cmd_bundle_revisions(Command):
60
 
    """Generate a revision bundle.
61
 
 
62
 
    This bundle contains all of the meta-information of a
63
 
    diff, rather than just containing the patch information.
64
 
 
65
 
    You can apply it to another tree using 'bzr merge'.
66
 
 
67
 
    bzr bundle
68
 
        - Bundle for the last commit
69
 
    bzr bundle BASE
70
 
        - Bundle to apply the current tree into BASE
71
 
    bzr bundle --revision A
72
 
        - Bundle for revision A
73
 
    bzr bundle --revision A..B
74
 
        - Bundle to transform A into B
75
 
    bzr bundle --revision A..B BASE
76
 
        - Bundle to transform revision A of BASE into revision B
77
 
          of the local tree
78
 
    """
79
 
    takes_options = ['verbose', 'revision']
80
 
    takes_args = ['base?']
81
 
    aliases = ['bundle']
82
 
 
83
 
    def run(self, base=None, revision=None):
84
 
        from bzrlib import user_encoding
85
 
        from bzrlib.bundle.serializer import write_bundle
86
 
 
87
 
        if base is None:
88
 
            base_branch = None
89
 
        else:
90
 
            base_branch = Branch.open(base)
91
 
 
92
 
        # We don't want to lock the same branch across
93
 
        # 2 different branches
94
 
        target_branch = Branch.open_containing(u'.')[0]
95
 
        if base_branch is not None and target_branch.base == base_branch.base:
96
 
            base_branch = None
97
 
 
98
 
        base_revision = None
99
 
        if revision is None:
100
 
            target_revision = target_branch.last_revision()
101
 
        elif len(revision) == 1:
102
 
            target_revision = revision[0].in_history(target_branch).rev_id
103
 
            if base_branch is not None:
104
 
                base_revision = base_branch.last_revision()
105
 
        elif len(revision) == 2:
106
 
            target_revision = revision[1].in_history(target_branch).rev_id
107
 
            if base_branch is not None:
108
 
                base_revision = revision[0].in_history(base_branch).rev_id
109
 
            else:
110
 
                base_revision = revision[0].in_history(target_branch).rev_id
111
 
        else:
112
 
            raise errors.BzrCommandError('--revision takes 1 or 2 parameters')
113
 
 
114
 
        if revision is None or len(revision) == 1:
115
 
            if base_branch is not None:
116
 
                target_branch.repository.fetch(base_branch.repository, 
117
 
                                               base_branch.last_revision())
118
 
                base_revision = common_ancestor(base_branch.last_revision(),
119
 
                                                target_revision,
120
 
                                                target_branch.repository)
121
 
                if base_revision is None:
122
 
                    base_revision = NULL_REVISION
123
 
 
124
 
        if base_revision is None:
125
 
            rev = target_branch.repository.get_revision(target_revision)
126
 
            if rev.parent_ids:
127
 
                base_revision = rev.parent_ids[0]
128
 
            else:
129
 
                base_revision = NULL_REVISION
130
 
 
131
 
        if base_branch is not None:
132
 
            target_branch.repository.fetch(base_branch.repository, 
133
 
                                           revision_id=base_revision)
134
 
            del base_branch
135
 
        write_bundle(target_branch.repository, target_revision, base_revision,
136
 
                     sys.stdout)
137
 
 
138
 
 
139
 
class cmd_verify_changeset(Command):
140
 
    """Read a written changeset, and make sure it is valid.
141
 
 
142
 
    """
143
 
    takes_args = ['filename?']
144
 
 
145
 
    def run(self, filename=None):
146
 
        from read_changeset import read_changeset
147
 
        #from bzrlib.xml import serializer_v4
148
 
 
149
 
        b, relpath = Branch.open_containing('.')
150
 
 
151
 
        if filename is None or filename == '-':
152
 
            f = sys.stdin
153
 
        else:
154
 
            f = open(filename, 'U')
155
 
 
156
 
        cset_info, cset_tree = read_changeset(f, b)
157
 
        # print cset_info
158
 
        # print cset_tree
159
 
        #serializer_v4.write(cset_tree.inventory, sys.stdout)
 
40
from bzrlib.trace import note
 
41
 
 
42
 
 
43
class cmd_bundle_info(Command):
 
44
    """Output interesting stats about a bundle"""
 
45
 
 
46
    hidden = True
 
47
    takes_args = ['location']
 
48
    takes_options = ['verbose']
 
49
    encoding_type = 'exact'
 
50
 
 
51
    def run(self, location, verbose=False):
 
52
        from bzrlib.bundle.serializer import read_bundle
 
53
        from bzrlib.bundle import read_mergeable_from_url
 
54
        from bzrlib import osutils
 
55
        term_encoding = osutils.get_terminal_encoding()
 
56
        bundle_info = read_mergeable_from_url(location)
 
57
        if isinstance(bundle_info, merge_directive._BaseMergeDirective):
 
58
            bundle_file = StringIO(bundle_info.get_raw_bundle())
 
59
            bundle_info = read_bundle(bundle_file)
 
60
        else:
 
61
            if verbose:
 
62
                raise errors.BzrCommandError('--verbose requires a merge'
 
63
                    ' directive')
 
64
        reader_method = getattr(bundle_info, 'get_bundle_reader', None)
 
65
        if reader_method is None:
 
66
            raise errors.BzrCommandError('Bundle format not supported')
 
67
 
 
68
        by_kind = {}
 
69
        file_ids = set()
 
70
        for bytes, parents, repo_kind, revision_id, file_id\
 
71
            in reader_method().iter_records():
 
72
            by_kind.setdefault(repo_kind, []).append(
 
73
                (bytes, parents, repo_kind, revision_id, file_id))
 
74
            if file_id is not None:
 
75
                file_ids.add(file_id)
 
76
        self.outf.write('Records\n')
 
77
        for kind, records in sorted(by_kind.iteritems()):
 
78
            multiparent = sum(1 for b, m, k, r, f in records if
 
79
                              len(m.get('parents', [])) > 1)
 
80
            self.outf.write('%s: %d (%d multiparent)\n' % \
 
81
                (kind, len(records), multiparent))
 
82
        self.outf.write('unique files: %d\n' % len(file_ids))
 
83
        self.outf.write('\n')
 
84
        nicks = set()
 
85
        committers = set()
 
86
        for revision in bundle_info.real_revisions:
 
87
            if 'branch-nick' in revision.properties:
 
88
                nicks.add(revision.properties['branch-nick'])
 
89
            committers.add(revision.committer)
 
90
 
 
91
        self.outf.write('Revisions\n')
 
92
        self.outf.write(('nicks: %s\n'
 
93
            % ', '.join(sorted(nicks))).encode(term_encoding, 'replace'))
 
94
        self.outf.write(('committers: \n%s\n' %
 
95
        '\n'.join(sorted(committers)).encode(term_encoding, 'replace')))
 
96
        if verbose:
 
97
            self.outf.write('\n')
 
98
            bundle_file.seek(0)
 
99
            line = bundle_file.readline()
 
100
            line = bundle_file.readline()
 
101
            content = bundle_file.read().decode('bz2')
 
102
            self.outf.write("Decoded contents\n")
 
103
            self.outf.write(content)
 
104
            self.outf.write('\n')