← Back to branch summary

~abentley/bzrtools/bzrtools.dev

« back to all changes in this revision

Viewing changes to __init__.py

  • Committer: Aaron Bentley
  • Date: 2006-03-16 14:53:00 UTC
  • mfrom: (0.1.96 shelf)
  • mto: This revision was merged to the branch mainline in revision 334.
  • Revision ID: abentley@panoramicfeedback.com-20060316145300-836889d55437eb15
Merge shelf v2

Show diffs side-by-side

added added

removed removed

Lines of Context:
__init__.py
4
4
"""
5
5
import bzrlib.commands
6
6
import push
 
7
from errors import CommandError
 
8
from patchsource import BzrPatchSource
7
9
from shelf import Shelf
8
10
import sys
9
11
import os.path
13
15
from reweave_inventory import cmd_fix
14
16
sys.path.insert(0, os.path.realpath(os.path.join(os.path.dirname(__file__), 
15
17
                                                 "external")))
 
18
from bzrlib import DEFAULT_IGNORE
 
19
 
 
20
 
 
21
DEFAULT_IGNORE.append('./.shelf')
 
22
DEFAULT_IGNORE.append('./.bzr-shelf*')
 
23
 
16
24
 
17
25
Option.OPTIONS['ignored'] = Option('ignored',
18
26
        help='delete all ignored files.')
110
118
        b = Branch.open_containing('.')[0]
111
119
        return patch(b, filename, strip)
112
120
 
113
 
 
114
121
class cmd_shelve(bzrlib.commands.Command):
115
 
    """Temporarily remove some text changes from the current tree.
116
 
    Use 'unshelve' to restore these changes.
 
122
    """Temporarily set aside some changes from the current tree.
 
123
 
 
124
    Shelve allows you to temporarily put changes you've made "on the shelf",
 
125
    ie. out of the way, until a later time when you can bring them back from
 
126
    the shelf with the 'unshelve' command.
117
127
 
118
128
    Shelve is intended to help separate several sets of text changes that have
119
129
    been inappropriately mingled.  If you just want to get rid of all changes
120
130
    (text and otherwise) and you don't need to restore them later, use revert.
121
131
    If you want to shelve all text changes at once, use shelve --all.
122
132
 
123
 
    If filenames are specified, only changes to those files will be shelved.
124
 
    If a revision is specified, all changes since that revision will may be
125
 
    shelved.
 
133
    By default shelve asks you what you want to shelve, press '?' at the
 
134
    prompt to get help. To shelve everything run shelve --all.
 
135
 
 
136
    You can put multiple items on the shelf, each time you run unshelve the
 
137
    most recently shelved changes will be reinstated.
 
138
 
 
139
    If filenames are specified, only the changes to those files will be
 
140
    shelved, other files will be left untouched.
 
141
 
 
142
    If a revision is specified, changes since that revision will be shelved.
126
143
    """
 
144
 
127
145
    takes_args = ['file*']
128
 
    takes_options = [Option('all', 
129
 
                            help='Shelve all changes without prompting'), 
130
 
                     'message', 'revision']
 
146
    takes_options = ['message', 'revision',
 
147
            Option('all', help='Shelve all changes without prompting')]
 
148
 
131
149
    def run(self, all=False, file_list=None, message=None, revision=None):
132
 
        if file_list is not None and len(file_list) > 0:
133
 
            branchdir = file_list[0]
134
 
        else:
135
 
            branchdir = '.'
136
 
 
137
150
        if revision is not None and revision:
138
151
            if len(revision) == 1:
139
152
                revision = revision[0]
140
153
            else:
141
 
                raise BzrCommandError("shelve only accepts a single revision "
 
154
                raise CommandError("shelve only accepts a single revision "
142
155
                                  "parameter.")
143
156
 
144
 
        s = Shelf(branchdir)
145
 
        return s.shelve(all, message, revision, file_list)
 
157
        source = BzrPatchSource(revision, file_list)
 
158
        s = Shelf(source.base)
 
159
        s.shelve(source, all, message)
 
160
        return 0
 
161
 
 
162
class cmd_shelf(bzrlib.commands.Command):
 
163
    """Perform various operations on your shelved patches. See also shelve.
 
164
 
 
165
    Subcommands:
 
166
        list   (ls)           List the patches on the current shelf.
 
167
        delete (del) <patch>  Delete a patch from the current shelf.
 
168
        switch       <shelf>  Switch to the named shelf, create it if necessary.
 
169
        show         <patch>  Show the contents of the specified patch.
 
170
        upgrade               Upgrade old format shelves.
 
171
    """
 
172
    takes_args = ['subcommand', 'args*']
 
173
 
 
174
    def run(self, subcommand, args_list):
 
175
        import sys
 
176
 
 
177
        source = BzrPatchSource()
 
178
        s = Shelf(source.base)
 
179
 
 
180
        if subcommand == 'ls' or subcommand == 'list':
 
181
            self.__check_no_args(args_list, "shelf list takes no arguments!")
 
182
            s.list()
 
183
        elif subcommand == 'delete' or subcommand == 'del':
 
184
            self.__check_one_arg(args_list, "shelf delete takes one argument!")
 
185
            s.delete(args_list[0])
 
186
        elif subcommand == 'switch':
 
187
            self.__check_one_arg(args_list, "shelf switch takes one argument!")
 
188
            s = Shelf(source.base, args_list[0])
 
189
            s.make_default()
 
190
        elif subcommand == 'show':
 
191
            self.__check_one_arg(args_list, "shelf show takes one argument!")
 
192
            s.display(args_list[0])
 
193
        elif subcommand == 'upgrade':
 
194
            self.__check_no_args(args_list, "shelf upgrade takes no arguments!")
 
195
            s.upgrade()
 
196
        else:
 
197
            print subcommand, args_list
 
198
            print >>sys.stderr, "Unknown shelf subcommand '%s'" % subcommand
 
199
 
 
200
    def __check_one_arg(self, args, msg):
 
201
        if args is None or len(args) != 1:
 
202
            raise CommandError(msg)
 
203
 
 
204
    def __check_no_args(self, args, msg):
 
205
        if args is not None:
 
206
            raise CommandError(msg)
146
207
 
147
208
 
148
209
class cmd_unshelve(bzrlib.commands.Command):
149
 
    """Restore previously-shelved changes to the current tree.
150
 
    See also 'shelve'.
 
210
    """Restore the most recently shelved changes to the current tree.
 
211
    See 'shelve' for more information.
151
212
    """
152
 
    def run(self):
153
 
        s = Shelf('.')
154
 
        return s.unshelve()
 
213
    takes_options = [
 
214
            Option('all', help='Unshelve all changes without prompting'),
 
215
            Option('force', help='Force unshelving even if errors occur'),
 
216
    ]
 
217
    def run(self, all=False, force=False):
 
218
        source = BzrPatchSource()
 
219
        s = Shelf(source.base)
 
220
        s.unshelve(source, all, force)
 
221
        return 0
 
222
 
155
223
 
156
224
class cmd_shell(bzrlib.commands.Command):
157
225
    """Begin an interactive shell tailored for bzr.
188
256
        from branchhistory import branch_history 
189
257
        return branch_history(branch)
190
258
 
191
 
commands = [cmd_shelve, cmd_unshelve, cmd_clean_tree, cmd_graph_ancestry,
192
 
            cmd_fetch_ghosts, cmd_patch, cmd_shell, cmd_fix, cmd_branch_history]
 
259
commands = [cmd_shelve, cmd_unshelve, cmd_shelf, cmd_clean_tree,
 
260
            cmd_graph_ancestry, cmd_fetch_ghosts, cmd_patch, cmd_shell,
 
261
            cmd_fix, cmd_branch_history]
193
262
 
194
263
command_decorators = []
195
264
 
239
308
 
240
309
def test_suite():
241
310
    import baz_import
 
311
    from bzrlib.tests.TestUtil import TestLoader
242
312
    import tests
243
313
    from doctest import DocTestSuite, ELLIPSIS
244
 
    from unittest import TestSuite, TestLoader
 
314
    from unittest import TestSuite
245
315
    import clean_tree
246
316
    import blackbox
247
317
    import shelf_tests