~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/bundle/commands.py

  • Committer: mbp at sourcefrog
  • Date: 2005-03-09 04:51:05 UTC
  • Revision ID: mbp@sourcefrog.net-20050309045105-d02cd410a115da2c
import all docs from arch

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
#!/usr/bin/env python
2
 
"""\
3
 
This is an attempt to take the internal delta object, and represent
4
 
it as a single-file text-only changeset.
5
 
This should have commands for both generating a changeset,
6
 
and for applying a changeset.
7
 
"""
8
 
 
9
 
import sys
10
 
 
11
 
from bzrlib.branch import Branch
12
 
from bzrlib.commands import Command, register_command
13
 
import bzrlib.errors as errors
14
 
from bzrlib.option import Option
15
 
from bzrlib.revision import (common_ancestor, MultipleRevisionSources,
16
 
                             NULL_REVISION)
17
 
from bzrlib.revisionspec import RevisionSpec
18
 
from bzrlib.trace import note
19
 
 
20
 
 
21
 
class cmd_send_changeset(Command):
22
 
    """Send a bundled up changset via mail.
23
 
 
24
 
    If no revision has been specified, the last commited change will
25
 
    be sent.
26
 
 
27
 
    Subject of the mail can be specified by the --message option,
28
 
    otherwise information from the changeset log will be used.
29
 
 
30
 
    A editor will be spawned where the user may enter a description
31
 
    of the changeset.  The description can be read from a file with
32
 
    the --file FILE option.
33
 
    """
34
 
    takes_options = ['revision', 'message', 'file']
35
 
    takes_args = ['to?']
36
 
 
37
 
    def run(self, to=None, message=None, revision=None, file=None):
38
 
        from bzrlib.errors import BzrCommandError
39
 
        from send_changeset import send_changeset
40
 
        
41
 
        if isinstance(revision, (list, tuple)):
42
 
            if len(revision) > 1:
43
 
                raise BzrCommandError('We do not support rollup-changesets yet.')
44
 
            revision = revision[0]
45
 
 
46
 
        b = Branch.open_containing('.')
47
 
 
48
 
        if not to:
49
 
            try:
50
 
                to = b.controlfile('x-send-address', 'rb').read().strip('\n')
51
 
            except:
52
 
                raise BzrCommandError('destination address is not known')
53
 
 
54
 
        if not isinstance(revision, (list, tuple)):
55
 
            revision = [revision]
56
 
 
57
 
        send_changeset(b, revision, to, message, file)
58
 
 
59
 
 
60
 
class cmd_bundle_revisions(Command):
61
 
    """Generate a revision bundle.
62
 
 
63
 
    This bundle contains all of the meta-information of a
64
 
    diff, rather than just containing the patch information.
65
 
 
66
 
    You can apply it to another tree using 'bzr merge'.
67
 
 
68
 
    bzr bundle-revisions
69
 
        - Bundle for the last commit
70
 
    bzr bundle-revisions BASE
71
 
        - Bundle to apply the current tree into BASE
72
 
    bzr bundle-revisions --revision A
73
 
        - Bundle for revision A
74
 
    bzr bundle-revisions --revision A..B
75
 
        - Bundle to transform A into B
76
 
    bzr bundle-revisions --revision A..B BASE
77
 
        - Bundle to transform revision A of BASE into revision B
78
 
          of the local tree
79
 
    """
80
 
    takes_options = ['verbose', 'revision',
81
 
                     Option("output", help="write bundle to specified file",
82
 
                            type=unicode)]
83
 
    takes_args = ['base?']
84
 
    aliases = ['bundle']
85
 
 
86
 
    def run(self, base=None, revision=None, output=None):
87
 
        from bzrlib import user_encoding
88
 
        from bzrlib.bundle.serializer import write_bundle
89
 
 
90
 
        target_branch = Branch.open_containing(u'.')[0]
91
 
 
92
 
        if base is None:
93
 
            base = target_branch.get_parent()
94
 
            if base is None:
95
 
                raise errors.BzrCommandError("No base branch known or"
96
 
                                             " specified.")
97
 
            else:
98
 
                note('Using saved location: %s' % base)
99
 
        base_branch = Branch.open(base)
100
 
 
101
 
        # We don't want to lock the same branch across
102
 
        # 2 different branches
103
 
        if target_branch.base == base_branch.base:
104
 
            base_branch = target_branch 
105
 
 
106
 
        base_revision = None
107
 
        if revision is None:
108
 
            target_revision = target_branch.last_revision()
109
 
        elif len(revision) == 1:
110
 
            target_revision = revision[0].in_history(target_branch).rev_id
111
 
            if base_branch is not None:
112
 
                base_revision = base_branch.last_revision()
113
 
        elif len(revision) == 2:
114
 
            target_revision = revision[1].in_history(target_branch).rev_id
115
 
            if base_branch is not None:
116
 
                base_revision = revision[0].in_history(base_branch).rev_id
117
 
            else:
118
 
                base_revision = revision[0].in_history(target_branch).rev_id
119
 
        else:
120
 
            raise errors.BzrCommandError('--revision takes 1 or 2 parameters')
121
 
 
122
 
        if revision is None or len(revision) == 1:
123
 
            if base_branch is not None:
124
 
                target_branch.repository.fetch(base_branch.repository, 
125
 
                                               base_branch.last_revision())
126
 
                base_revision = common_ancestor(base_branch.last_revision(),
127
 
                                                target_revision,
128
 
                                                target_branch.repository)
129
 
                if base_revision is None:
130
 
                    base_revision = NULL_REVISION
131
 
 
132
 
        if base_revision is None:
133
 
            rev = target_branch.repository.get_revision(target_revision)
134
 
            if rev.parent_ids:
135
 
                base_revision = rev.parent_ids[0]
136
 
            else:
137
 
                base_revision = NULL_REVISION
138
 
 
139
 
        if base_branch is not None:
140
 
            target_branch.repository.fetch(base_branch.repository, 
141
 
                                           revision_id=base_revision)
142
 
            del base_branch
143
 
 
144
 
        if output is not None:
145
 
            fileobj = file(output, 'wb')
146
 
        else:
147
 
            fileobj = sys.stdout
148
 
        write_bundle(target_branch.repository, target_revision, base_revision,
149
 
                     fileobj)
150
 
 
151
 
 
152
 
class cmd_verify_changeset(Command):
153
 
    """Read a written changeset, and make sure it is valid.
154
 
 
155
 
    """
156
 
    takes_args = ['filename?']
157
 
 
158
 
    def run(self, filename=None):
159
 
        from read_changeset import read_changeset
160
 
        #from bzrlib.xml import serializer_v4
161
 
 
162
 
        b, relpath = Branch.open_containing('.')
163
 
 
164
 
        if filename is None or filename == '-':
165
 
            f = sys.stdin
166
 
        else:
167
 
            f = open(filename, 'U')
168
 
 
169
 
        cset_info, cset_tree = read_changeset(f, b)
170
 
        # print cset_info
171
 
        # print cset_tree
172
 
        #serializer_v4.write(cset_tree.inventory, sys.stdout)