~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: Martin Pool
  • Date: 2010-12-16 06:24:14 UTC
  • mfrom: (5538.2.4 bzr-docs-textfixes)
  • mto: This revision was merged to the branch mainline in revision 5572.
  • Revision ID: mbp@sourcefrog.net-20101216062414-y14p9t3otmmbtpsw
merge uppercasing of acronyms

Show diffs side-by-side

added added

removed removed

Lines of Context:
20
20
 
21
21
from bzrlib.lazy_import import lazy_import
22
22
lazy_import(globals(), """
23
 
import codecs
24
23
import cStringIO
 
24
import itertools
 
25
import re
25
26
import sys
26
27
import time
27
28
 
33
34
    bzrdir,
34
35
    directory_service,
35
36
    delta,
36
 
    config,
 
37
    config as _mod_config,
37
38
    errors,
38
39
    globbing,
39
40
    hooks,
75
76
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
76
77
 
77
78
 
 
79
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
78
80
def tree_files(file_list, default_branch=u'.', canonicalize=True,
79
81
    apply_view=True):
80
 
    try:
81
 
        return internal_tree_files(file_list, default_branch, canonicalize,
82
 
            apply_view)
83
 
    except errors.FileInWrongBranch, e:
84
 
        raise errors.BzrCommandError("%s is not in the same branch as %s" %
85
 
                                     (e.path, file_list[0]))
 
82
    return internal_tree_files(file_list, default_branch, canonicalize,
 
83
        apply_view)
86
84
 
87
85
 
88
86
def tree_files_for_add(file_list):
152
150
 
153
151
# XXX: Bad function name; should possibly also be a class method of
154
152
# WorkingTree rather than a function.
 
153
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
155
154
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
156
155
    apply_view=True):
157
156
    """Convert command-line paths to a WorkingTree and relative paths.
158
157
 
 
158
    Deprecated: use WorkingTree.open_containing_paths instead.
 
159
 
159
160
    This is typically used for command-line processors that take one or
160
161
    more filenames, and infer the workingtree that contains them.
161
162
 
171
172
 
172
173
    :return: workingtree, [relative_paths]
173
174
    """
174
 
    if file_list is None or len(file_list) == 0:
175
 
        tree = WorkingTree.open_containing(default_branch)[0]
176
 
        if tree.supports_views() and apply_view:
177
 
            view_files = tree.views.lookup_view()
178
 
            if view_files:
179
 
                file_list = view_files
180
 
                view_str = views.view_display_str(view_files)
181
 
                note("Ignoring files outside view. View is %s" % view_str)
182
 
        return tree, file_list
183
 
    tree = WorkingTree.open_containing(osutils.realpath(file_list[0]))[0]
184
 
    return tree, safe_relpath_files(tree, file_list, canonicalize,
185
 
        apply_view=apply_view)
186
 
 
187
 
 
188
 
def safe_relpath_files(tree, file_list, canonicalize=True, apply_view=True):
189
 
    """Convert file_list into a list of relpaths in tree.
190
 
 
191
 
    :param tree: A tree to operate on.
192
 
    :param file_list: A list of user provided paths or None.
193
 
    :param apply_view: if True and a view is set, apply it or check that
194
 
        specified files are within it
195
 
    :return: A list of relative paths.
196
 
    :raises errors.PathNotChild: When a provided path is in a different tree
197
 
        than tree.
198
 
    """
199
 
    if file_list is None:
200
 
        return None
201
 
    if tree.supports_views() and apply_view:
202
 
        view_files = tree.views.lookup_view()
203
 
    else:
204
 
        view_files = []
205
 
    new_list = []
206
 
    # tree.relpath exists as a "thunk" to osutils, but canonical_relpath
207
 
    # doesn't - fix that up here before we enter the loop.
208
 
    if canonicalize:
209
 
        fixer = lambda p: osutils.canonical_relpath(tree.basedir, p)
210
 
    else:
211
 
        fixer = tree.relpath
212
 
    for filename in file_list:
213
 
        try:
214
 
            relpath = fixer(osutils.dereference_path(filename))
215
 
            if  view_files and not osutils.is_inside_any(view_files, relpath):
216
 
                raise errors.FileOutsideView(filename, view_files)
217
 
            new_list.append(relpath)
218
 
        except errors.PathNotChild:
219
 
            raise errors.FileInWrongBranch(tree.branch, filename)
220
 
    return new_list
 
175
    return WorkingTree.open_containing_paths(
 
176
        file_list, default_directory='.',
 
177
        canonicalize=True,
 
178
        apply_view=True)
221
179
 
222
180
 
223
181
def _get_view_info_for_change_reporter(tree):
232
190
    return view_info
233
191
 
234
192
 
 
193
def _open_directory_or_containing_tree_or_branch(filename, directory):
 
194
    """Open the tree or branch containing the specified file, unless
 
195
    the --directory option is used to specify a different branch."""
 
196
    if directory is not None:
 
197
        return (None, Branch.open(directory), filename)
 
198
    return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
199
 
 
200
 
235
201
# TODO: Make sure no commands unconditionally use the working directory as a
236
202
# branch.  If a filename argument is used, the first of them should be used to
237
203
# specify the branch.  (Perhaps this can be factored out into some kind of
286
252
    To skip the display of pending merge information altogether, use
287
253
    the no-pending option or specify a file/directory.
288
254
 
289
 
    If a revision argument is given, the status is calculated against
290
 
    that revision, or between two revisions if two are provided.
 
255
    To compare the working directory to a specific revision, pass a
 
256
    single revision to the revision argument.
 
257
 
 
258
    To see which files have changed in a specific revision, or between
 
259
    two revisions, pass a revision range to the revision argument.
 
260
    This will produce the same results as calling 'bzr diff --summarize'.
291
261
    """
292
262
 
293
263
    # TODO: --no-recurse, --recurse options
315
285
            raise errors.BzrCommandError('bzr status --revision takes exactly'
316
286
                                         ' one or two revision specifiers')
317
287
 
318
 
        tree, relfile_list = tree_files(file_list)
 
288
        tree, relfile_list = WorkingTree.open_containing_paths(file_list)
319
289
        # Avoid asking for specific files when that is not needed.
320
290
        if relfile_list == ['']:
321
291
            relfile_list = None
340
310
 
341
311
    hidden = True
342
312
    takes_args = ['revision_id?']
343
 
    takes_options = ['revision']
 
313
    takes_options = ['directory', 'revision']
344
314
    # cat-revision is more for frontends so should be exact
345
315
    encoding = 'strict'
346
316
 
353
323
        self.outf.write(revtext.decode('utf-8'))
354
324
 
355
325
    @display_command
356
 
    def run(self, revision_id=None, revision=None):
 
326
    def run(self, revision_id=None, revision=None, directory=u'.'):
357
327
        if revision_id is not None and revision is not None:
358
328
            raise errors.BzrCommandError('You can only supply one of'
359
329
                                         ' revision_id or --revision')
360
330
        if revision_id is None and revision is None:
361
331
            raise errors.BzrCommandError('You must supply either'
362
332
                                         ' --revision or a revision_id')
363
 
        b = WorkingTree.open_containing(u'.')[0].branch
 
333
        b = WorkingTree.open_containing(directory)[0].branch
364
334
 
365
335
        revisions = b.repository.revisions
366
336
        if revisions is None:
483
453
    takes_options = [
484
454
        Option('force',
485
455
               help='Remove the working tree even if it has '
486
 
                    'uncommitted changes.'),
 
456
                    'uncommitted or shelved changes.'),
487
457
        ]
488
458
 
489
459
    def run(self, location_list, force=False):
503
473
            if not force:
504
474
                if (working.has_changes()):
505
475
                    raise errors.UncommittedChanges(working)
 
476
                if working.get_shelf_manager().last_shelf() is not None:
 
477
                    raise errors.ShelvedChanges(working)
506
478
 
507
479
            if working.user_url != working.branch.user_url:
508
480
                raise errors.BzrCommandError("You cannot remove the working tree"
528
500
        if tree:
529
501
            try:
530
502
                wt = WorkingTree.open_containing(location)[0]
531
 
                wt.lock_read()
 
503
                self.add_cleanup(wt.lock_read().unlock)
532
504
            except (errors.NoWorkingTree, errors.NotLocalUrl):
533
505
                raise errors.NoWorkingTree(location)
534
 
            self.add_cleanup(wt.unlock)
535
506
            revid = wt.last_revision()
536
507
            try:
537
508
                revno_t = wt.branch.revision_id_to_dotted_revno(revid)
540
511
            revno = ".".join(str(n) for n in revno_t)
541
512
        else:
542
513
            b = Branch.open_containing(location)[0]
543
 
            b.lock_read()
544
 
            self.add_cleanup(b.unlock)
 
514
            self.add_cleanup(b.lock_read().unlock)
545
515
            revno = b.revno()
546
516
        self.cleanup_now()
547
517
        self.outf.write(str(revno) + '\n')
554
524
    takes_args = ['revision_info*']
555
525
    takes_options = [
556
526
        'revision',
557
 
        Option('directory',
 
527
        custom_help('directory',
558
528
            help='Branch to examine, '
559
 
                 'rather than the one containing the working directory.',
560
 
            short_name='d',
561
 
            type=unicode,
562
 
            ),
 
529
                 'rather than the one containing the working directory.'),
563
530
        Option('tree', help='Show revno of working tree'),
564
531
        ]
565
532
 
570
537
        try:
571
538
            wt = WorkingTree.open_containing(directory)[0]
572
539
            b = wt.branch
573
 
            wt.lock_read()
574
 
            self.add_cleanup(wt.unlock)
 
540
            self.add_cleanup(wt.lock_read().unlock)
575
541
        except (errors.NoWorkingTree, errors.NotLocalUrl):
576
542
            wt = None
577
543
            b = Branch.open_containing(directory)[0]
578
 
            b.lock_read()
579
 
            self.add_cleanup(b.unlock)
 
544
            self.add_cleanup(b.lock_read().unlock)
580
545
        revision_ids = []
581
546
        if revision is not None:
582
547
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
681
646
                should_print=(not is_quiet()))
682
647
 
683
648
        if base_tree:
684
 
            base_tree.lock_read()
685
 
            self.add_cleanup(base_tree.unlock)
 
649
            self.add_cleanup(base_tree.lock_read().unlock)
686
650
        tree, file_list = tree_files_for_add(file_list)
687
651
        added, ignored = tree.smart_add(file_list, not
688
652
            no_recurse, action=action, save=not dry_run)
759
723
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
760
724
 
761
725
        revision = _get_one_revision('inventory', revision)
762
 
        work_tree, file_list = tree_files(file_list)
763
 
        work_tree.lock_read()
764
 
        self.add_cleanup(work_tree.unlock)
 
726
        work_tree, file_list = WorkingTree.open_containing_paths(file_list)
 
727
        self.add_cleanup(work_tree.lock_read().unlock)
765
728
        if revision is not None:
766
729
            tree = revision.as_tree(work_tree.branch)
767
730
 
768
731
            extra_trees = [work_tree]
769
 
            tree.lock_read()
770
 
            self.add_cleanup(tree.unlock)
 
732
            self.add_cleanup(tree.lock_read().unlock)
771
733
        else:
772
734
            tree = work_tree
773
735
            extra_trees = []
832
794
            names_list = []
833
795
        if len(names_list) < 2:
834
796
            raise errors.BzrCommandError("missing file argument")
835
 
        tree, rel_names = tree_files(names_list, canonicalize=False)
836
 
        tree.lock_tree_write()
837
 
        self.add_cleanup(tree.unlock)
 
797
        tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
 
798
        self.add_cleanup(tree.lock_tree_write().unlock)
838
799
        self._run(tree, names_list, rel_names, after)
839
800
 
840
801
    def run_auto(self, names_list, after, dry_run):
844
805
        if after:
845
806
            raise errors.BzrCommandError('--after cannot be specified with'
846
807
                                         ' --auto.')
847
 
        work_tree, file_list = tree_files(names_list, default_branch='.')
848
 
        work_tree.lock_tree_write()
849
 
        self.add_cleanup(work_tree.unlock)
 
808
        work_tree, file_list = WorkingTree.open_containing_paths(
 
809
            names_list, default_directory='.')
 
810
        self.add_cleanup(work_tree.lock_tree_write().unlock)
850
811
        rename_map.RenameMap.guess_renames(work_tree, dry_run)
851
812
 
852
813
    def _run(self, tree, names_list, rel_names, after):
960
921
    takes_options = ['remember', 'overwrite', 'revision',
961
922
        custom_help('verbose',
962
923
            help='Show logs of pulled revisions.'),
963
 
        Option('directory',
 
924
        custom_help('directory',
964
925
            help='Branch to pull into, '
965
 
                 'rather than the one containing the working directory.',
966
 
            short_name='d',
967
 
            type=unicode,
968
 
            ),
 
926
                 'rather than the one containing the working directory.'),
969
927
        Option('local',
970
928
            help="Perform a local pull in a bound "
971
929
                 "branch.  Local pulls are not applied to "
972
930
                 "the master branch."
973
931
            ),
 
932
        Option('show-base',
 
933
            help="Show base revision text in conflicts.")
974
934
        ]
975
935
    takes_args = ['location?']
976
936
    encoding_type = 'replace'
977
937
 
978
938
    def run(self, location=None, remember=False, overwrite=False,
979
939
            revision=None, verbose=False,
980
 
            directory=None, local=False):
 
940
            directory=None, local=False,
 
941
            show_base=False):
981
942
        # FIXME: too much stuff is in the command class
982
943
        revision_id = None
983
944
        mergeable = None
986
947
        try:
987
948
            tree_to = WorkingTree.open_containing(directory)[0]
988
949
            branch_to = tree_to.branch
989
 
            tree_to.lock_write()
990
 
            self.add_cleanup(tree_to.unlock)
 
950
            self.add_cleanup(tree_to.lock_write().unlock)
991
951
        except errors.NoWorkingTree:
992
952
            tree_to = None
993
953
            branch_to = Branch.open_containing(directory)[0]
994
 
            branch_to.lock_write()
995
 
            self.add_cleanup(branch_to.unlock)
 
954
            self.add_cleanup(branch_to.lock_write().unlock)
 
955
 
 
956
        if tree_to is None and show_base:
 
957
            raise errors.BzrCommandError("Need working tree for --show-base.")
996
958
 
997
959
        if local and not branch_to.get_bound_location():
998
960
            raise errors.LocalRequiresBoundBranch()
1029
991
        else:
1030
992
            branch_from = Branch.open(location,
1031
993
                possible_transports=possible_transports)
1032
 
            branch_from.lock_read()
1033
 
            self.add_cleanup(branch_from.unlock)
 
994
            self.add_cleanup(branch_from.lock_read().unlock)
1034
995
 
1035
996
            if branch_to.get_parent() is None or remember:
1036
997
                branch_to.set_parent(branch_from.base)
1045
1006
                view_info=view_info)
1046
1007
            result = tree_to.pull(
1047
1008
                branch_from, overwrite, revision_id, change_reporter,
1048
 
                possible_transports=possible_transports, local=local)
 
1009
                possible_transports=possible_transports, local=local,
 
1010
                show_base=show_base)
1049
1011
        else:
1050
1012
            result = branch_to.pull(
1051
1013
                branch_from, overwrite, revision_id, local=local)
1088
1050
        Option('create-prefix',
1089
1051
               help='Create the path leading up to the branch '
1090
1052
                    'if it does not already exist.'),
1091
 
        Option('directory',
 
1053
        custom_help('directory',
1092
1054
            help='Branch to push from, '
1093
 
                 'rather than the one containing the working directory.',
1094
 
            short_name='d',
1095
 
            type=unicode,
1096
 
            ),
 
1055
                 'rather than the one containing the working directory.'),
1097
1056
        Option('use-existing-dir',
1098
1057
               help='By default push will fail if the target'
1099
1058
                    ' directory exists, but does not already'
1110
1069
        Option('strict',
1111
1070
               help='Refuse to push if there are uncommitted changes in'
1112
1071
               ' the working tree, --no-strict disables the check.'),
 
1072
        Option('no-tree',
 
1073
               help="Don't populate the working tree, even for protocols"
 
1074
               " that support it."),
1113
1075
        ]
1114
1076
    takes_args = ['location?']
1115
1077
    encoding_type = 'replace'
1117
1079
    def run(self, location=None, remember=False, overwrite=False,
1118
1080
        create_prefix=False, verbose=False, revision=None,
1119
1081
        use_existing_dir=False, directory=None, stacked_on=None,
1120
 
        stacked=False, strict=None):
 
1082
        stacked=False, strict=None, no_tree=False):
1121
1083
        from bzrlib.push import _show_push_branch
1122
1084
 
1123
1085
        if directory is None:
1169
1131
        _show_push_branch(br_from, revision_id, location, self.outf,
1170
1132
            verbose=verbose, overwrite=overwrite, remember=remember,
1171
1133
            stacked_on=stacked_on, create_prefix=create_prefix,
1172
 
            use_existing_dir=use_existing_dir)
 
1134
            use_existing_dir=use_existing_dir, no_tree=no_tree)
1173
1135
 
1174
1136
 
1175
1137
class cmd_branch(Command):
1188
1150
 
1189
1151
    _see_also = ['checkout']
1190
1152
    takes_args = ['from_location', 'to_location?']
1191
 
    takes_options = ['revision', Option('hardlink',
1192
 
        help='Hard-link working tree files where possible.'),
 
1153
    takes_options = ['revision',
 
1154
        Option('hardlink', help='Hard-link working tree files where possible.'),
 
1155
        Option('files-from', type=str,
 
1156
               help="Get file contents from this tree."),
1193
1157
        Option('no-tree',
1194
1158
            help="Create a branch without a working-tree."),
1195
1159
        Option('switch',
1213
1177
 
1214
1178
    def run(self, from_location, to_location=None, revision=None,
1215
1179
            hardlink=False, stacked=False, standalone=False, no_tree=False,
1216
 
            use_existing_dir=False, switch=False, bind=False):
 
1180
            use_existing_dir=False, switch=False, bind=False,
 
1181
            files_from=None):
1217
1182
        from bzrlib import switch as _mod_switch
1218
1183
        from bzrlib.tag import _merge_tags_if_possible
1219
1184
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1220
1185
            from_location)
 
1186
        if not (hardlink or files_from):
 
1187
            # accelerator_tree is usually slower because you have to read N
 
1188
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1189
            # explicitly request it
 
1190
            accelerator_tree = None
 
1191
        if files_from is not None and files_from != from_location:
 
1192
            accelerator_tree = WorkingTree.open(files_from)
1221
1193
        revision = _get_one_revision('branch', revision)
1222
 
        br_from.lock_read()
1223
 
        self.add_cleanup(br_from.unlock)
 
1194
        self.add_cleanup(br_from.lock_read().unlock)
1224
1195
        if revision is not None:
1225
1196
            revision_id = revision.as_revision_id(br_from)
1226
1197
        else:
1331
1302
            to_location = branch_location
1332
1303
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1333
1304
            branch_location)
 
1305
        if not (hardlink or files_from):
 
1306
            # accelerator_tree is usually slower because you have to read N
 
1307
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1308
            # explicitly request it
 
1309
            accelerator_tree = None
1334
1310
        revision = _get_one_revision('checkout', revision)
1335
 
        if files_from is not None:
 
1311
        if files_from is not None and files_from != branch_location:
1336
1312
            accelerator_tree = WorkingTree.open(files_from)
1337
1313
        if revision is not None:
1338
1314
            revision_id = revision.as_revision_id(source)
1366
1342
    @display_command
1367
1343
    def run(self, dir=u'.'):
1368
1344
        tree = WorkingTree.open_containing(dir)[0]
1369
 
        tree.lock_read()
1370
 
        self.add_cleanup(tree.unlock)
 
1345
        self.add_cleanup(tree.lock_read().unlock)
1371
1346
        new_inv = tree.inventory
1372
1347
        old_tree = tree.basis_tree()
1373
 
        old_tree.lock_read()
1374
 
        self.add_cleanup(old_tree.unlock)
 
1348
        self.add_cleanup(old_tree.lock_read().unlock)
1375
1349
        old_inv = old_tree.inventory
1376
1350
        renames = []
1377
1351
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1396
1370
    If you want to discard your local changes, you can just do a
1397
1371
    'bzr revert' instead of 'bzr commit' after the update.
1398
1372
 
 
1373
    If you want to restore a file that has been removed locally, use
 
1374
    'bzr revert' instead of 'bzr update'.
 
1375
 
1399
1376
    If the tree's branch is bound to a master branch, it will also update
1400
1377
    the branch from the master.
1401
1378
    """
1402
1379
 
1403
1380
    _see_also = ['pull', 'working-trees', 'status-flags']
1404
1381
    takes_args = ['dir?']
1405
 
    takes_options = ['revision']
 
1382
    takes_options = ['revision',
 
1383
                     Option('show-base',
 
1384
                            help="Show base revision text in conflicts."),
 
1385
                     ]
1406
1386
    aliases = ['up']
1407
1387
 
1408
 
    def run(self, dir='.', revision=None):
 
1388
    def run(self, dir='.', revision=None, show_base=None):
1409
1389
        if revision is not None and len(revision) != 1:
1410
1390
            raise errors.BzrCommandError(
1411
1391
                        "bzr update --revision takes exactly one revision")
1415
1395
        master = branch.get_master_branch(
1416
1396
            possible_transports=possible_transports)
1417
1397
        if master is not None:
1418
 
            tree.lock_write()
1419
1398
            branch_location = master.base
 
1399
            tree.lock_write()
1420
1400
        else:
 
1401
            branch_location = tree.branch.base
1421
1402
            tree.lock_tree_write()
1422
 
            branch_location = tree.branch.base
1423
1403
        self.add_cleanup(tree.unlock)
1424
1404
        # get rid of the final '/' and be ready for display
1425
1405
        branch_location = urlutils.unescape_for_display(
1451
1431
                change_reporter,
1452
1432
                possible_transports=possible_transports,
1453
1433
                revision=revision_id,
1454
 
                old_tip=old_tip)
 
1434
                old_tip=old_tip,
 
1435
                show_base=show_base)
1455
1436
        except errors.NoSuchRevision, e:
1456
1437
            raise errors.BzrCommandError(
1457
1438
                                  "branch has no revision %s\n"
1519
1500
class cmd_remove(Command):
1520
1501
    __doc__ = """Remove files or directories.
1521
1502
 
1522
 
    This makes bzr stop tracking changes to the specified files. bzr will delete
1523
 
    them if they can easily be recovered using revert. If no options or
1524
 
    parameters are given bzr will scan for files that are being tracked by bzr
1525
 
    but missing in your tree and stop tracking them for you.
 
1503
    This makes Bazaar stop tracking changes to the specified files. Bazaar will
 
1504
    delete them if they can easily be recovered using revert otherwise they
 
1505
    will be backed up (adding an extention of the form .~#~). If no options or
 
1506
    parameters are given Bazaar will scan for files that are being tracked by
 
1507
    Bazaar but missing in your tree and stop tracking them for you.
1526
1508
    """
1527
1509
    takes_args = ['file*']
1528
1510
    takes_options = ['verbose',
1530
1512
        RegistryOption.from_kwargs('file-deletion-strategy',
1531
1513
            'The file deletion mode to be used.',
1532
1514
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1533
 
            safe='Only delete files if they can be'
1534
 
                 ' safely recovered (default).',
 
1515
            safe='Backup changed files (default).',
1535
1516
            keep='Delete from bzr but leave the working copy.',
 
1517
            no_backup='Don\'t backup changed files.',
1536
1518
            force='Delete all the specified files, even if they can not be '
1537
 
                'recovered and even if they are non-empty directories.')]
 
1519
                'recovered and even if they are non-empty directories. '
 
1520
                '(deprecated, use no-backup)')]
1538
1521
    aliases = ['rm', 'del']
1539
1522
    encoding_type = 'replace'
1540
1523
 
1541
1524
    def run(self, file_list, verbose=False, new=False,
1542
1525
        file_deletion_strategy='safe'):
1543
 
        tree, file_list = tree_files(file_list)
 
1526
        if file_deletion_strategy == 'force':
 
1527
            note("(The --force option is deprecated, rather use --no-backup "
 
1528
                "in future.)")
 
1529
            file_deletion_strategy = 'no-backup'
 
1530
 
 
1531
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1544
1532
 
1545
1533
        if file_list is not None:
1546
1534
            file_list = [f for f in file_list]
1547
1535
 
1548
 
        tree.lock_write()
1549
 
        self.add_cleanup(tree.unlock)
 
1536
        self.add_cleanup(tree.lock_write().unlock)
1550
1537
        # Heuristics should probably all move into tree.remove_smart or
1551
1538
        # some such?
1552
1539
        if new:
1567
1554
            file_deletion_strategy = 'keep'
1568
1555
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1569
1556
            keep_files=file_deletion_strategy=='keep',
1570
 
            force=file_deletion_strategy=='force')
 
1557
            force=(file_deletion_strategy=='no-backup'))
1571
1558
 
1572
1559
 
1573
1560
class cmd_file_id(Command):
1635
1622
 
1636
1623
    _see_also = ['check']
1637
1624
    takes_args = ['branch?']
 
1625
    takes_options = [
 
1626
        Option('canonicalize-chks',
 
1627
               help='Make sure CHKs are in canonical form (repairs '
 
1628
                    'bug 522637).',
 
1629
               hidden=True),
 
1630
        ]
1638
1631
 
1639
 
    def run(self, branch="."):
 
1632
    def run(self, branch=".", canonicalize_chks=False):
1640
1633
        from bzrlib.reconcile import reconcile
1641
1634
        dir = bzrdir.BzrDir.open(branch)
1642
 
        reconcile(dir)
 
1635
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1643
1636
 
1644
1637
 
1645
1638
class cmd_revision_history(Command):
1722
1715
                ),
1723
1716
         Option('append-revisions-only',
1724
1717
                help='Never change revnos or the existing log.'
1725
 
                '  Append revisions to it only.')
 
1718
                '  Append revisions to it only.'),
 
1719
         Option('no-tree',
 
1720
                'Create a branch without a working tree.')
1726
1721
         ]
1727
1722
    def run(self, location=None, format=None, append_revisions_only=False,
1728
 
            create_prefix=False):
 
1723
            create_prefix=False, no_tree=False):
1729
1724
        if format is None:
1730
1725
            format = bzrdir.format_registry.make_bzrdir('default')
1731
1726
        if location is None:
1754
1749
        except errors.NotBranchError:
1755
1750
            # really a NotBzrDir error...
1756
1751
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
1752
            if no_tree:
 
1753
                force_new_tree = False
 
1754
            else:
 
1755
                force_new_tree = None
1757
1756
            branch = create_branch(to_transport.base, format=format,
1758
 
                                   possible_transports=[to_transport])
 
1757
                                   possible_transports=[to_transport],
 
1758
                                   force_new_tree=force_new_tree)
1759
1759
            a_bzrdir = branch.bzrdir
1760
1760
        else:
1761
1761
            from bzrlib.transport.local import LocalTransport
1765
1765
                        raise errors.BranchExistsWithoutWorkingTree(location)
1766
1766
                raise errors.AlreadyBranchError(location)
1767
1767
            branch = a_bzrdir.create_branch()
1768
 
            a_bzrdir.create_workingtree()
 
1768
            if not no_tree:
 
1769
                a_bzrdir.create_workingtree()
1769
1770
        if append_revisions_only:
1770
1771
            try:
1771
1772
                branch.set_append_revisions_only(True)
1865
1866
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1866
1867
    produces patches suitable for "patch -p1".
1867
1868
 
 
1869
    Note that when using the -r argument with a range of revisions, the
 
1870
    differences are computed between the two specified revisions.  That
 
1871
    is, the command does not show the changes introduced by the first 
 
1872
    revision in the range.  This differs from the interpretation of 
 
1873
    revision ranges used by "bzr log" which includes the first revision
 
1874
    in the range.
 
1875
 
1868
1876
    :Exit values:
1869
1877
        1 - changed
1870
1878
        2 - unrepresentable changes
1888
1896
 
1889
1897
            bzr diff -r1..3 xxx
1890
1898
 
1891
 
        To see the changes introduced in revision X::
 
1899
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1900
 
 
1901
            bzr diff -c2
 
1902
 
 
1903
        To see the changes introduced by revision X::
1892
1904
        
1893
1905
            bzr diff -cX
1894
1906
 
1898
1910
 
1899
1911
            bzr diff -r<chosen_parent>..X
1900
1912
 
1901
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1913
        The changes between the current revision and the previous revision
 
1914
        (equivalent to -c-1 and -r-2..-1)
1902
1915
 
1903
 
            bzr diff -c2
 
1916
            bzr diff -r-2..
1904
1917
 
1905
1918
        Show just the differences for file NEWS::
1906
1919
 
1921
1934
        Same as 'bzr diff' but prefix paths with old/ and new/::
1922
1935
 
1923
1936
            bzr diff --prefix old/:new/
 
1937
            
 
1938
        Show the differences using a custom diff program with options::
 
1939
        
 
1940
            bzr diff --using /usr/bin/diff --diff-options -wu
1924
1941
    """
1925
1942
    _see_also = ['status']
1926
1943
    takes_args = ['file*']
1985
2002
         old_branch, new_branch,
1986
2003
         specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1987
2004
            file_list, revision, old, new, self.add_cleanup, apply_view=True)
 
2005
        # GNU diff on Windows uses ANSI encoding for filenames
 
2006
        path_encoding = osutils.get_diff_header_encoding()
1988
2007
        return show_diff_trees(old_tree, new_tree, sys.stdout,
1989
2008
                               specific_files=specific_files,
1990
2009
                               external_diff_options=diff_options,
1991
2010
                               old_label=old_label, new_label=new_label,
1992
 
                               extra_trees=extra_trees, using=using,
 
2011
                               extra_trees=extra_trees,
 
2012
                               path_encoding=path_encoding,
 
2013
                               using=using,
1993
2014
                               format_cls=format)
1994
2015
 
1995
2016
 
2003
2024
    # level of effort but possibly much less IO.  (Or possibly not,
2004
2025
    # if the directories are very large...)
2005
2026
    _see_also = ['status', 'ls']
2006
 
    takes_options = ['show-ids']
 
2027
    takes_options = ['directory', 'show-ids']
2007
2028
 
2008
2029
    @display_command
2009
 
    def run(self, show_ids=False):
2010
 
        tree = WorkingTree.open_containing(u'.')[0]
2011
 
        tree.lock_read()
2012
 
        self.add_cleanup(tree.unlock)
 
2030
    def run(self, show_ids=False, directory=u'.'):
 
2031
        tree = WorkingTree.open_containing(directory)[0]
 
2032
        self.add_cleanup(tree.lock_read().unlock)
2013
2033
        old = tree.basis_tree()
2014
 
        old.lock_read()
2015
 
        self.add_cleanup(old.unlock)
 
2034
        self.add_cleanup(old.lock_read().unlock)
2016
2035
        for path, ie in old.inventory.iter_entries():
2017
2036
            if not tree.has_id(ie.file_id):
2018
2037
                self.outf.write(path)
2028
2047
 
2029
2048
    hidden = True
2030
2049
    _see_also = ['status', 'ls']
2031
 
    takes_options = [
2032
 
            Option('null',
2033
 
                   help='Write an ascii NUL (\\0) separator '
2034
 
                   'between files rather than a newline.')
2035
 
            ]
 
2050
    takes_options = ['directory', 'null']
2036
2051
 
2037
2052
    @display_command
2038
 
    def run(self, null=False):
2039
 
        tree = WorkingTree.open_containing(u'.')[0]
 
2053
    def run(self, null=False, directory=u'.'):
 
2054
        tree = WorkingTree.open_containing(directory)[0]
2040
2055
        td = tree.changes_from(tree.basis_tree())
2041
2056
        for path, id, kind, text_modified, meta_modified in td.modified:
2042
2057
            if null:
2051
2066
 
2052
2067
    hidden = True
2053
2068
    _see_also = ['status', 'ls']
2054
 
    takes_options = [
2055
 
            Option('null',
2056
 
                   help='Write an ascii NUL (\\0) separator '
2057
 
                   'between files rather than a newline.')
2058
 
            ]
 
2069
    takes_options = ['directory', 'null']
2059
2070
 
2060
2071
    @display_command
2061
 
    def run(self, null=False):
2062
 
        wt = WorkingTree.open_containing(u'.')[0]
2063
 
        wt.lock_read()
2064
 
        self.add_cleanup(wt.unlock)
 
2072
    def run(self, null=False, directory=u'.'):
 
2073
        wt = WorkingTree.open_containing(directory)[0]
 
2074
        self.add_cleanup(wt.lock_read().unlock)
2065
2075
        basis = wt.basis_tree()
2066
 
        basis.lock_read()
2067
 
        self.add_cleanup(basis.unlock)
 
2076
        self.add_cleanup(basis.lock_read().unlock)
2068
2077
        basis_inv = basis.inventory
2069
2078
        inv = wt.inventory
2070
2079
        for file_id in inv:
2073
2082
            if inv.is_root(file_id) and len(basis_inv) == 0:
2074
2083
                continue
2075
2084
            path = inv.id2path(file_id)
2076
 
            if not os.access(osutils.abspath(path), os.F_OK):
 
2085
            if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2077
2086
                continue
2078
2087
            if null:
2079
2088
                self.outf.write(path + '\0')
2279
2288
                   help='Show just the specified revision.'
2280
2289
                   ' See also "help revisionspec".'),
2281
2290
            'log-format',
 
2291
            RegistryOption('authors',
 
2292
                'What names to list as authors - first, all or committer.',
 
2293
                title='Authors',
 
2294
                lazy_registry=('bzrlib.log', 'author_list_registry'),
 
2295
            ),
2282
2296
            Option('levels',
2283
2297
                   short_name='n',
2284
2298
                   help='Number of levels to display - 0 for all, 1 for flat.',
2319
2333
            limit=None,
2320
2334
            show_diff=False,
2321
2335
            include_merges=False,
 
2336
            authors=None,
2322
2337
            exclude_common_ancestry=False,
2323
2338
            ):
2324
2339
        from bzrlib.log import (
2352
2367
        if file_list:
2353
2368
            # find the file ids to log and check for directory filtering
2354
2369
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2355
 
                revision, file_list)
2356
 
            self.add_cleanup(b.unlock)
 
2370
                revision, file_list, self.add_cleanup)
2357
2371
            for relpath, file_id, kind in file_info_list:
2358
2372
                if file_id is None:
2359
2373
                    raise errors.BzrCommandError(
2377
2391
                location = '.'
2378
2392
            dir, relpath = bzrdir.BzrDir.open_containing(location)
2379
2393
            b = dir.open_branch()
2380
 
            b.lock_read()
2381
 
            self.add_cleanup(b.unlock)
 
2394
            self.add_cleanup(b.lock_read().unlock)
2382
2395
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2383
2396
 
2384
2397
        # Decide on the type of delta & diff filtering to use
2404
2417
                        show_timezone=timezone,
2405
2418
                        delta_format=get_verbosity_level(),
2406
2419
                        levels=levels,
2407
 
                        show_advice=levels is None)
 
2420
                        show_advice=levels is None,
 
2421
                        author_list_handler=authors)
2408
2422
 
2409
2423
        # Choose the algorithm for doing the logging. It's annoying
2410
2424
        # having multiple code paths like this but necessary until
2508
2522
        tree, relpath = WorkingTree.open_containing(filename)
2509
2523
        file_id = tree.path2id(relpath)
2510
2524
        b = tree.branch
2511
 
        b.lock_read()
2512
 
        self.add_cleanup(b.unlock)
 
2525
        self.add_cleanup(b.lock_read().unlock)
2513
2526
        touching_revs = log.find_touching_revisions(b, file_id)
2514
2527
        for revno, revision_id, what in touching_revs:
2515
2528
            self.outf.write("%6d %s\n" % (revno, what))
2528
2541
                   help='Recurse into subdirectories.'),
2529
2542
            Option('from-root',
2530
2543
                   help='Print paths relative to the root of the branch.'),
2531
 
            Option('unknown', help='Print unknown files.'),
 
2544
            Option('unknown', short_name='u',
 
2545
                help='Print unknown files.'),
2532
2546
            Option('versioned', help='Print versioned files.',
2533
2547
                   short_name='V'),
2534
 
            Option('ignored', help='Print ignored files.'),
2535
 
            Option('null',
2536
 
                   help='Write an ascii NUL (\\0) separator '
2537
 
                   'between files rather than a newline.'),
2538
 
            Option('kind',
 
2548
            Option('ignored', short_name='i',
 
2549
                help='Print ignored files.'),
 
2550
            Option('kind', short_name='k',
2539
2551
                   help='List entries of a particular kind: file, directory, symlink.',
2540
2552
                   type=unicode),
 
2553
            'null',
2541
2554
            'show-ids',
 
2555
            'directory',
2542
2556
            ]
2543
2557
    @display_command
2544
2558
    def run(self, revision=None, verbose=False,
2545
2559
            recursive=False, from_root=False,
2546
2560
            unknown=False, versioned=False, ignored=False,
2547
 
            null=False, kind=None, show_ids=False, path=None):
 
2561
            null=False, kind=None, show_ids=False, path=None, directory=None):
2548
2562
 
2549
2563
        if kind and kind not in ('file', 'directory', 'symlink'):
2550
2564
            raise errors.BzrCommandError('invalid kind specified')
2562
2576
                raise errors.BzrCommandError('cannot specify both --from-root'
2563
2577
                                             ' and PATH')
2564
2578
            fs_path = path
2565
 
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2566
 
            fs_path)
 
2579
        tree, branch, relpath = \
 
2580
            _open_directory_or_containing_tree_or_branch(fs_path, directory)
2567
2581
 
2568
2582
        # Calculate the prefix to use
2569
2583
        prefix = None
2584
2598
                view_str = views.view_display_str(view_files)
2585
2599
                note("Ignoring files outside view. View is %s" % view_str)
2586
2600
 
2587
 
        tree.lock_read()
2588
 
        self.add_cleanup(tree.unlock)
 
2601
        self.add_cleanup(tree.lock_read().unlock)
2589
2602
        for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2590
2603
            from_dir=relpath, recursive=recursive):
2591
2604
            # Apply additional masking
2638
2651
 
2639
2652
    hidden = True
2640
2653
    _see_also = ['ls']
 
2654
    takes_options = ['directory']
2641
2655
 
2642
2656
    @display_command
2643
 
    def run(self):
2644
 
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
2657
    def run(self, directory=u'.'):
 
2658
        for f in WorkingTree.open_containing(directory)[0].unknowns():
2645
2659
            self.outf.write(osutils.quotefn(f) + '\n')
2646
2660
 
2647
2661
 
2674
2688
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2675
2689
    precedence over the '!' exception patterns.
2676
2690
 
2677
 
    Note: ignore patterns containing shell wildcards must be quoted from
2678
 
    the shell on Unix.
 
2691
    :Notes: 
 
2692
        
 
2693
    * Ignore patterns containing shell wildcards must be quoted from
 
2694
      the shell on Unix.
 
2695
 
 
2696
    * Ignore patterns starting with "#" act as comments in the ignore file.
 
2697
      To ignore patterns that begin with that character, use the "RE:" prefix.
2679
2698
 
2680
2699
    :Examples:
2681
2700
        Ignore the top level Makefile::
2690
2709
 
2691
2710
            bzr ignore "!special.class"
2692
2711
 
 
2712
        Ignore files whose name begins with the "#" character::
 
2713
 
 
2714
            bzr ignore "RE:^#"
 
2715
 
2693
2716
        Ignore .o files under the lib directory::
2694
2717
 
2695
2718
            bzr ignore "lib/**/*.o"
2712
2735
 
2713
2736
    _see_also = ['status', 'ignored', 'patterns']
2714
2737
    takes_args = ['name_pattern*']
2715
 
    takes_options = [
 
2738
    takes_options = ['directory',
2716
2739
        Option('default-rules',
2717
2740
               help='Display the default ignore rules that bzr uses.')
2718
2741
        ]
2719
2742
 
2720
 
    def run(self, name_pattern_list=None, default_rules=None):
 
2743
    def run(self, name_pattern_list=None, default_rules=None,
 
2744
            directory=u'.'):
2721
2745
        from bzrlib import ignores
2722
2746
        if default_rules is not None:
2723
2747
            # dump the default rules and exit
2729
2753
                "NAME_PATTERN or --default-rules.")
2730
2754
        name_pattern_list = [globbing.normalize_pattern(p)
2731
2755
                             for p in name_pattern_list]
 
2756
        bad_patterns = ''
 
2757
        for p in name_pattern_list:
 
2758
            if not globbing.Globster.is_pattern_valid(p):
 
2759
                bad_patterns += ('\n  %s' % p)
 
2760
        if bad_patterns:
 
2761
            msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
 
2762
            ui.ui_factory.show_error(msg)
 
2763
            raise errors.InvalidPattern('')
2732
2764
        for name_pattern in name_pattern_list:
2733
2765
            if (name_pattern[0] == '/' or
2734
2766
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2735
2767
                raise errors.BzrCommandError(
2736
2768
                    "NAME_PATTERN should not be an absolute path")
2737
 
        tree, relpath = WorkingTree.open_containing(u'.')
 
2769
        tree, relpath = WorkingTree.open_containing(directory)
2738
2770
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2739
2771
        ignored = globbing.Globster(name_pattern_list)
2740
2772
        matches = []
2741
 
        tree.lock_read()
 
2773
        self.add_cleanup(tree.lock_read().unlock)
2742
2774
        for entry in tree.list_files():
2743
2775
            id = entry[3]
2744
2776
            if id is not None:
2745
2777
                filename = entry[0]
2746
2778
                if ignored.match(filename):
2747
2779
                    matches.append(filename)
2748
 
        tree.unlock()
2749
2780
        if len(matches) > 0:
2750
2781
            self.outf.write("Warning: the following files are version controlled and"
2751
2782
                  " match your ignore pattern:\n%s"
2766
2797
 
2767
2798
    encoding_type = 'replace'
2768
2799
    _see_also = ['ignore', 'ls']
 
2800
    takes_options = ['directory']
2769
2801
 
2770
2802
    @display_command
2771
 
    def run(self):
2772
 
        tree = WorkingTree.open_containing(u'.')[0]
2773
 
        tree.lock_read()
2774
 
        self.add_cleanup(tree.unlock)
 
2803
    def run(self, directory=u'.'):
 
2804
        tree = WorkingTree.open_containing(directory)[0]
 
2805
        self.add_cleanup(tree.lock_read().unlock)
2775
2806
        for path, file_class, kind, file_id, entry in tree.list_files():
2776
2807
            if file_class != 'I':
2777
2808
                continue
2788
2819
    """
2789
2820
    hidden = True
2790
2821
    takes_args = ['revno']
 
2822
    takes_options = ['directory']
2791
2823
 
2792
2824
    @display_command
2793
 
    def run(self, revno):
 
2825
    def run(self, revno, directory=u'.'):
2794
2826
        try:
2795
2827
            revno = int(revno)
2796
2828
        except ValueError:
2797
2829
            raise errors.BzrCommandError("not a valid revision-number: %r"
2798
2830
                                         % revno)
2799
 
        revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
 
2831
        revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2800
2832
        self.outf.write("%s\n" % revid)
2801
2833
 
2802
2834
 
2829
2861
      =================       =========================
2830
2862
    """
2831
2863
    takes_args = ['dest', 'branch_or_subdir?']
2832
 
    takes_options = [
 
2864
    takes_options = ['directory',
2833
2865
        Option('format',
2834
2866
               help="Type of file to export to.",
2835
2867
               type=unicode),
2844
2876
                    'revision in which it was changed.'),
2845
2877
        ]
2846
2878
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2847
 
        root=None, filters=False, per_file_timestamps=False):
 
2879
        root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2848
2880
        from bzrlib.export import export
2849
2881
 
2850
2882
        if branch_or_subdir is None:
2851
 
            tree = WorkingTree.open_containing(u'.')[0]
 
2883
            tree = WorkingTree.open_containing(directory)[0]
2852
2884
            b = tree.branch
2853
2885
            subdir = None
2854
2886
        else:
2873
2905
    """
2874
2906
 
2875
2907
    _see_also = ['ls']
2876
 
    takes_options = [
 
2908
    takes_options = ['directory',
2877
2909
        Option('name-from-revision', help='The path name in the old tree.'),
2878
2910
        Option('filters', help='Apply content filters to display the '
2879
2911
                'convenience form.'),
2884
2916
 
2885
2917
    @display_command
2886
2918
    def run(self, filename, revision=None, name_from_revision=False,
2887
 
            filters=False):
 
2919
            filters=False, directory=None):
2888
2920
        if revision is not None and len(revision) != 1:
2889
2921
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
2890
2922
                                         " one revision specifier")
2891
2923
        tree, branch, relpath = \
2892
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2893
 
        branch.lock_read()
2894
 
        self.add_cleanup(branch.unlock)
 
2924
            _open_directory_or_containing_tree_or_branch(filename, directory)
 
2925
        self.add_cleanup(branch.lock_read().unlock)
2895
2926
        return self._run(tree, branch, relpath, filename, revision,
2896
2927
                         name_from_revision, filters)
2897
2928
 
2900
2931
        if tree is None:
2901
2932
            tree = b.basis_tree()
2902
2933
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2903
 
        rev_tree.lock_read()
2904
 
        self.add_cleanup(rev_tree.unlock)
 
2934
        self.add_cleanup(rev_tree.lock_read().unlock)
2905
2935
 
2906
2936
        old_file_id = rev_tree.path2id(relpath)
2907
2937
 
3128
3158
 
3129
3159
        properties = {}
3130
3160
 
3131
 
        tree, selected_list = tree_files(selected_list)
 
3161
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3132
3162
        if selected_list == ['']:
3133
3163
            # workaround - commit of root of tree should be exactly the same
3134
3164
            # as just default commit in that tree, and succeed even though
3169
3199
        def get_message(commit_obj):
3170
3200
            """Callback to get commit message"""
3171
3201
            if file:
3172
 
                my_message = codecs.open(
3173
 
                    file, 'rt', osutils.get_user_encoding()).read()
 
3202
                f = open(file)
 
3203
                try:
 
3204
                    my_message = f.read().decode(osutils.get_user_encoding())
 
3205
                finally:
 
3206
                    f.close()
3174
3207
            elif message is not None:
3175
3208
                my_message = message
3176
3209
            else:
3205
3238
                        reporter=None, verbose=verbose, revprops=properties,
3206
3239
                        authors=author, timestamp=commit_stamp,
3207
3240
                        timezone=offset,
3208
 
                        exclude=safe_relpath_files(tree, exclude))
 
3241
                        exclude=tree.safe_relpath_files(exclude))
3209
3242
        except PointlessCommit:
3210
3243
            raise errors.BzrCommandError("No changes to commit."
3211
3244
                              " Use --unchanged to commit anyhow.")
3330
3363
 
3331
3364
            bzr whoami "Frank Chu <fchu@example.com>"
3332
3365
    """
3333
 
    takes_options = [ Option('email',
 
3366
    takes_options = [ 'directory',
 
3367
                      Option('email',
3334
3368
                             help='Display email address only.'),
3335
3369
                      Option('branch',
3336
3370
                             help='Set identity for the current branch instead of '
3340
3374
    encoding_type = 'replace'
3341
3375
 
3342
3376
    @display_command
3343
 
    def run(self, email=False, branch=False, name=None):
 
3377
    def run(self, email=False, branch=False, name=None, directory=None):
3344
3378
        if name is None:
3345
 
            # use branch if we're inside one; otherwise global config
3346
 
            try:
3347
 
                c = Branch.open_containing('.')[0].get_config()
3348
 
            except errors.NotBranchError:
3349
 
                c = config.GlobalConfig()
 
3379
            if directory is None:
 
3380
                # use branch if we're inside one; otherwise global config
 
3381
                try:
 
3382
                    c = Branch.open_containing(u'.')[0].get_config()
 
3383
                except errors.NotBranchError:
 
3384
                    c = _mod_config.GlobalConfig()
 
3385
            else:
 
3386
                c = Branch.open(directory).get_config()
3350
3387
            if email:
3351
3388
                self.outf.write(c.user_email() + '\n')
3352
3389
            else:
3355
3392
 
3356
3393
        # display a warning if an email address isn't included in the given name.
3357
3394
        try:
3358
 
            config.extract_email_address(name)
 
3395
            _mod_config.extract_email_address(name)
3359
3396
        except errors.NoEmailInUsername, e:
3360
3397
            warning('"%s" does not seem to contain an email address.  '
3361
3398
                    'This is allowed, but not recommended.', name)
3362
3399
 
3363
3400
        # use global config unless --branch given
3364
3401
        if branch:
3365
 
            c = Branch.open_containing('.')[0].get_config()
 
3402
            if directory is None:
 
3403
                c = Branch.open_containing(u'.')[0].get_config()
 
3404
            else:
 
3405
                c = Branch.open(directory).get_config()
3366
3406
        else:
3367
 
            c = config.GlobalConfig()
 
3407
            c = _mod_config.GlobalConfig()
3368
3408
        c.set_user_option('email', name)
3369
3409
 
3370
3410
 
3380
3420
 
3381
3421
    _see_also = ['info']
3382
3422
    takes_args = ['nickname?']
3383
 
    def run(self, nickname=None):
3384
 
        branch = Branch.open_containing(u'.')[0]
 
3423
    takes_options = ['directory']
 
3424
    def run(self, nickname=None, directory=u'.'):
 
3425
        branch = Branch.open_containing(directory)[0]
3385
3426
        if nickname is None:
3386
3427
            self.printme(branch)
3387
3428
        else:
3436
3477
                'bzr alias --remove expects an alias to remove.')
3437
3478
        # If alias is not found, print something like:
3438
3479
        # unalias: foo: not found
3439
 
        c = config.GlobalConfig()
 
3480
        c = _mod_config.GlobalConfig()
3440
3481
        c.unset_alias(alias_name)
3441
3482
 
3442
3483
    @display_command
3443
3484
    def print_aliases(self):
3444
3485
        """Print out the defined aliases in a similar format to bash."""
3445
 
        aliases = config.GlobalConfig().get_aliases()
 
3486
        aliases = _mod_config.GlobalConfig().get_aliases()
3446
3487
        for key, value in sorted(aliases.iteritems()):
3447
3488
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
3448
3489
 
3458
3499
 
3459
3500
    def set_alias(self, alias_name, alias_command):
3460
3501
        """Save the alias in the global config."""
3461
 
        c = config.GlobalConfig()
 
3502
        c = _mod_config.GlobalConfig()
3462
3503
        c.set_alias(alias_name, alias_command)
3463
3504
 
3464
3505
 
3499
3540
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3500
3541
    into a pdb postmortem session.
3501
3542
 
 
3543
    The --coverage=DIRNAME global option produces a report with covered code
 
3544
    indicated.
 
3545
 
3502
3546
    :Examples:
3503
3547
        Run only tests relating to 'ignore'::
3504
3548
 
3537
3581
                                 'throughout the test suite.',
3538
3582
                            type=get_transport_type),
3539
3583
                     Option('benchmark',
3540
 
                            help='Run the benchmarks rather than selftests.'),
 
3584
                            help='Run the benchmarks rather than selftests.',
 
3585
                            hidden=True),
3541
3586
                     Option('lsprof-timed',
3542
3587
                            help='Generate lsprof output for benchmarked'
3543
3588
                                 ' sections of code.'),
3544
3589
                     Option('lsprof-tests',
3545
3590
                            help='Generate lsprof output for each test.'),
3546
 
                     Option('cache-dir', type=str,
3547
 
                            help='Cache intermediate benchmark output in this '
3548
 
                                 'directory.'),
3549
3591
                     Option('first',
3550
3592
                            help='Run all tests, but run specified tests first.',
3551
3593
                            short_name='f',
3585
3627
 
3586
3628
    def run(self, testspecs_list=None, verbose=False, one=False,
3587
3629
            transport=None, benchmark=None,
3588
 
            lsprof_timed=None, cache_dir=None,
 
3630
            lsprof_timed=None,
3589
3631
            first=False, list_only=False,
3590
3632
            randomize=None, exclude=None, strict=False,
3591
3633
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3592
3634
            parallel=None, lsprof_tests=False):
3593
 
        from bzrlib.tests import selftest
3594
 
        import bzrlib.benchmarks as benchmarks
3595
 
        from bzrlib.benchmarks import tree_creator
3596
 
 
3597
 
        # Make deprecation warnings visible, unless -Werror is set
3598
 
        symbol_versioning.activate_deprecation_warnings(override=False)
3599
 
 
3600
 
        if cache_dir is not None:
3601
 
            tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
 
3635
        from bzrlib import tests
 
3636
 
3602
3637
        if testspecs_list is not None:
3603
3638
            pattern = '|'.join(testspecs_list)
3604
3639
        else:
3612
3647
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3613
3648
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3614
3649
            # stdout, which would corrupt the subunit stream. 
3615
 
            if sys.platform == "win32" and sys.stdout.fileno() >= 0:
 
3650
            # FIXME: This has been fixed in subunit trunk (>0.0.5) so the
 
3651
            # following code can be deleted when it's sufficiently deployed
 
3652
            # -- vila/mgz 20100514
 
3653
            if (sys.platform == "win32"
 
3654
                and getattr(sys.stdout, 'fileno', None) is not None):
3616
3655
                import msvcrt
3617
3656
                msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3618
3657
        if parallel:
3619
3658
            self.additional_selftest_args.setdefault(
3620
3659
                'suite_decorators', []).append(parallel)
3621
3660
        if benchmark:
3622
 
            test_suite_factory = benchmarks.test_suite
3623
 
            # Unless user explicitly asks for quiet, be verbose in benchmarks
3624
 
            verbose = not is_quiet()
3625
 
            # TODO: should possibly lock the history file...
3626
 
            benchfile = open(".perf_history", "at", buffering=1)
3627
 
            self.add_cleanup(benchfile.close)
3628
 
        else:
3629
 
            test_suite_factory = None
3630
 
            benchfile = None
 
3661
            raise errors.BzrCommandError(
 
3662
                "--benchmark is no longer supported from bzr 2.2; "
 
3663
                "use bzr-usertest instead")
 
3664
        test_suite_factory = None
3631
3665
        selftest_kwargs = {"verbose": verbose,
3632
3666
                          "pattern": pattern,
3633
3667
                          "stop_on_failure": one,
3635
3669
                          "test_suite_factory": test_suite_factory,
3636
3670
                          "lsprof_timed": lsprof_timed,
3637
3671
                          "lsprof_tests": lsprof_tests,
3638
 
                          "bench_history": benchfile,
3639
3672
                          "matching_tests_first": first,
3640
3673
                          "list_only": list_only,
3641
3674
                          "random_seed": randomize,
3646
3679
                          "starting_with": starting_with
3647
3680
                          }
3648
3681
        selftest_kwargs.update(self.additional_selftest_args)
3649
 
        result = selftest(**selftest_kwargs)
 
3682
 
 
3683
        # Make deprecation warnings visible, unless -Werror is set
 
3684
        cleanup = symbol_versioning.activate_deprecation_warnings(
 
3685
            override=False)
 
3686
        try:
 
3687
            result = tests.selftest(**selftest_kwargs)
 
3688
        finally:
 
3689
            cleanup()
3650
3690
        return int(not result)
3651
3691
 
3652
3692
 
3690
3730
 
3691
3731
        branch1 = Branch.open_containing(branch)[0]
3692
3732
        branch2 = Branch.open_containing(other)[0]
3693
 
        branch1.lock_read()
3694
 
        self.add_cleanup(branch1.unlock)
3695
 
        branch2.lock_read()
3696
 
        self.add_cleanup(branch2.unlock)
 
3733
        self.add_cleanup(branch1.lock_read().unlock)
 
3734
        self.add_cleanup(branch2.lock_read().unlock)
3697
3735
        last1 = ensure_null(branch1.last_revision())
3698
3736
        last2 = ensure_null(branch2.last_revision())
3699
3737
 
3711
3749
    with bzr send. If neither is specified, the default is the upstream branch
3712
3750
    or the branch most recently merged using --remember.
3713
3751
 
3714
 
    When merging a branch, by default the tip will be merged. To pick a different
3715
 
    revision, pass --revision. If you specify two values, the first will be used as
3716
 
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
3717
 
    available revisions, like this is commonly referred to as "cherrypicking".
3718
 
 
3719
 
    Revision numbers are always relative to the branch being merged.
3720
 
 
3721
 
    By default, bzr will try to merge in all new work from the other
3722
 
    branch, automatically determining an appropriate base.  If this
3723
 
    fails, you may need to give an explicit base.
 
3752
    When merging from a branch, by default bzr will try to merge in all new
 
3753
    work from the other branch, automatically determining an appropriate base
 
3754
    revision.  If this fails, you may need to give an explicit base.
 
3755
 
 
3756
    To pick a different ending revision, pass "--revision OTHER".  bzr will
 
3757
    try to merge in all new work up to and including revision OTHER.
 
3758
 
 
3759
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
 
3760
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
 
3761
    causes some revisions to be skipped, i.e. if the destination branch does
 
3762
    not already contain revision BASE, such a merge is commonly referred to as
 
3763
    a "cherrypick".
 
3764
 
 
3765
    Revision numbers are always relative to the source branch.
3724
3766
 
3725
3767
    Merge will do its best to combine the changes in two branches, but there
3726
3768
    are some kinds of problems only a human can fix.  When it encounters those,
3750
3792
    you to apply each diff hunk and file change, similar to "shelve".
3751
3793
 
3752
3794
    :Examples:
3753
 
        To merge the latest revision from bzr.dev::
 
3795
        To merge all new revisions from bzr.dev::
3754
3796
 
3755
3797
            bzr merge ../bzr.dev
3756
3798
 
3793
3835
                ' completely merged into the source, pull from the'
3794
3836
                ' source rather than merging.  When this happens,'
3795
3837
                ' you do not need to commit the result.'),
3796
 
        Option('directory',
 
3838
        custom_help('directory',
3797
3839
               help='Branch to merge into, '
3798
 
                    'rather than the one containing the working directory.',
3799
 
               short_name='d',
3800
 
               type=unicode,
3801
 
               ),
 
3840
                    'rather than the one containing the working directory.'),
3802
3841
        Option('preview', help='Instead of merging, show a diff of the'
3803
3842
               ' merge.'),
3804
3843
        Option('interactive', help='Select changes interactively.',
3837
3876
            unversioned_filter=tree.is_ignored, view_info=view_info)
3838
3877
        pb = ui.ui_factory.nested_progress_bar()
3839
3878
        self.add_cleanup(pb.finished)
3840
 
        tree.lock_write()
3841
 
        self.add_cleanup(tree.unlock)
 
3879
        self.add_cleanup(tree.lock_write().unlock)
3842
3880
        if location is not None:
3843
3881
            try:
3844
3882
                mergeable = bundle.read_mergeable_from_url(location,
3905
3943
    def _do_preview(self, merger):
3906
3944
        from bzrlib.diff import show_diff_trees
3907
3945
        result_tree = self._get_preview(merger)
 
3946
        path_encoding = osutils.get_diff_header_encoding()
3908
3947
        show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
 
                        old_label='', new_label='')
 
3948
                        old_label='', new_label='',
 
3949
                        path_encoding=path_encoding)
3910
3950
 
3911
3951
    def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
3952
        merger.change_reporter = change_reporter
3992
4032
        if ((remember or tree.branch.get_submit_branch() is None) and
3993
4033
             user_location is not None):
3994
4034
            tree.branch.set_submit_branch(other_branch.base)
3995
 
        _merge_tags_if_possible(other_branch, tree.branch)
 
4035
        # Merge tags (but don't set them in the master branch yet, the user
 
4036
        # might revert this merge).  Commit will propagate them.
 
4037
        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3996
4038
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3997
4039
            other_revision_id, base_revision_id, other_branch, base_branch)
3998
4040
        if other_path != '':
4099
4141
        from bzrlib.conflicts import restore
4100
4142
        if merge_type is None:
4101
4143
            merge_type = _mod_merge.Merge3Merger
4102
 
        tree, file_list = tree_files(file_list)
4103
 
        tree.lock_write()
4104
 
        self.add_cleanup(tree.unlock)
 
4144
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4145
        self.add_cleanup(tree.lock_write().unlock)
4105
4146
        parents = tree.get_parent_ids()
4106
4147
        if len(parents) != 2:
4107
4148
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
4167
4208
    last committed revision is used.
4168
4209
 
4169
4210
    To remove only some changes, without reverting to a prior version, use
4170
 
    merge instead.  For example, "merge . --revision -2..-3" will remove the
4171
 
    changes introduced by -2, without affecting the changes introduced by -1.
4172
 
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
 
4211
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
 
4212
    will remove the changes introduced by the second last commit (-2), without
 
4213
    affecting the changes introduced by the last commit (-1).  To remove
 
4214
    certain changes on a hunk-by-hunk basis, see the shelve command.
4173
4215
 
4174
4216
    By default, any files that have been manually changed will be backed up
4175
4217
    first.  (Files changed only by merge are not backed up.)  Backup files have
4205
4247
    target branches.
4206
4248
    """
4207
4249
 
4208
 
    _see_also = ['cat', 'export']
 
4250
    _see_also = ['cat', 'export', 'merge', 'shelve']
4209
4251
    takes_options = [
4210
4252
        'revision',
4211
4253
        Option('no-backup', "Do not save backups of reverted files."),
4216
4258
 
4217
4259
    def run(self, revision=None, no_backup=False, file_list=None,
4218
4260
            forget_merges=None):
4219
 
        tree, file_list = tree_files(file_list)
4220
 
        tree.lock_tree_write()
4221
 
        self.add_cleanup(tree.unlock)
 
4261
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4262
        self.add_cleanup(tree.lock_tree_write().unlock)
4222
4263
        if forget_merges:
4223
4264
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4224
4265
        else:
4313
4354
    _see_also = ['merge', 'pull']
4314
4355
    takes_args = ['other_branch?']
4315
4356
    takes_options = [
 
4357
        'directory',
4316
4358
        Option('reverse', 'Reverse the order of revisions.'),
4317
4359
        Option('mine-only',
4318
4360
               'Display changes in the local branch only.'),
4340
4382
            theirs_only=False,
4341
4383
            log_format=None, long=False, short=False, line=False,
4342
4384
            show_ids=False, verbose=False, this=False, other=False,
4343
 
            include_merges=False, revision=None, my_revision=None):
 
4385
            include_merges=False, revision=None, my_revision=None,
 
4386
            directory=u'.'):
4344
4387
        from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4388
        def message(s):
4346
4389
            if not is_quiet():
4359
4402
        elif theirs_only:
4360
4403
            restrict = 'remote'
4361
4404
 
4362
 
        local_branch = Branch.open_containing(u".")[0]
4363
 
        local_branch.lock_read()
4364
 
        self.add_cleanup(local_branch.unlock)
 
4405
        local_branch = Branch.open_containing(directory)[0]
 
4406
        self.add_cleanup(local_branch.lock_read().unlock)
4365
4407
 
4366
4408
        parent = local_branch.get_parent()
4367
4409
        if other_branch is None:
4378
4420
        if remote_branch.base == local_branch.base:
4379
4421
            remote_branch = local_branch
4380
4422
        else:
4381
 
            remote_branch.lock_read()
4382
 
            self.add_cleanup(remote_branch.unlock)
 
4423
            self.add_cleanup(remote_branch.lock_read().unlock)
4383
4424
 
4384
4425
        local_revid_range = _revision_range_to_revid_range(
4385
4426
            _get_revision_range(my_revision, local_branch,
4440
4481
            message("Branches are up to date.\n")
4441
4482
        self.cleanup_now()
4442
4483
        if not status_code and parent is None and other_branch is not None:
4443
 
            local_branch.lock_write()
4444
 
            self.add_cleanup(local_branch.unlock)
 
4484
            self.add_cleanup(local_branch.lock_write().unlock)
4445
4485
            # handle race conditions - a parent might be set while we run.
4446
4486
            if local_branch.get_parent() is None:
4447
4487
                local_branch.set_parent(remote_branch.base)
4547
4587
            b = Branch.open_containing(branch)[0]
4548
4588
        else:
4549
4589
            b = Branch.open(branch)
4550
 
        b.lock_read()
4551
 
        self.add_cleanup(b.unlock)
 
4590
        self.add_cleanup(b.lock_read().unlock)
4552
4591
        if revision is None:
4553
4592
            rev_id = b.last_revision()
4554
4593
        else:
4578
4617
                     Option('long', help='Show commit date in annotations.'),
4579
4618
                     'revision',
4580
4619
                     'show-ids',
 
4620
                     'directory',
4581
4621
                     ]
4582
4622
    encoding_type = 'exact'
4583
4623
 
4584
4624
    @display_command
4585
4625
    def run(self, filename, all=False, long=False, revision=None,
4586
 
            show_ids=False):
 
4626
            show_ids=False, directory=None):
4587
4627
        from bzrlib.annotate import annotate_file, annotate_file_tree
4588
4628
        wt, branch, relpath = \
4589
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
4629
            _open_directory_or_containing_tree_or_branch(filename, directory)
4590
4630
        if wt is not None:
4591
 
            wt.lock_read()
4592
 
            self.add_cleanup(wt.unlock)
 
4631
            self.add_cleanup(wt.lock_read().unlock)
4593
4632
        else:
4594
 
            branch.lock_read()
4595
 
            self.add_cleanup(branch.unlock)
 
4633
            self.add_cleanup(branch.lock_read().unlock)
4596
4634
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4597
 
        tree.lock_read()
4598
 
        self.add_cleanup(tree.unlock)
 
4635
        self.add_cleanup(tree.lock_read().unlock)
4599
4636
        if wt is not None:
4600
4637
            file_id = wt.path2id(relpath)
4601
4638
        else:
4619
4656
 
4620
4657
    hidden = True # is this right ?
4621
4658
    takes_args = ['revision_id*']
4622
 
    takes_options = ['revision']
 
4659
    takes_options = ['directory', 'revision']
4623
4660
 
4624
 
    def run(self, revision_id_list=None, revision=None):
 
4661
    def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4662
        if revision_id_list is not None and revision is not None:
4626
4663
            raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4664
        if revision_id_list is None and revision is None:
4628
4665
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4629
 
        b = WorkingTree.open_containing(u'.')[0].branch
4630
 
        b.lock_write()
4631
 
        self.add_cleanup(b.unlock)
 
4666
        b = WorkingTree.open_containing(directory)[0].branch
 
4667
        self.add_cleanup(b.lock_write().unlock)
4632
4668
        return self._run(b, revision_id_list, revision)
4633
4669
 
4634
4670
    def _run(self, b, revision_id_list, revision):
4693
4729
 
4694
4730
    _see_also = ['checkouts', 'unbind']
4695
4731
    takes_args = ['location?']
4696
 
    takes_options = []
 
4732
    takes_options = ['directory']
4697
4733
 
4698
 
    def run(self, location=None):
4699
 
        b, relpath = Branch.open_containing(u'.')
 
4734
    def run(self, location=None, directory=u'.'):
 
4735
        b, relpath = Branch.open_containing(directory)
4700
4736
        if location is None:
4701
4737
            try:
4702
4738
                location = b.get_old_bound_location()
4729
4765
 
4730
4766
    _see_also = ['checkouts', 'bind']
4731
4767
    takes_args = []
4732
 
    takes_options = []
 
4768
    takes_options = ['directory']
4733
4769
 
4734
 
    def run(self):
4735
 
        b, relpath = Branch.open_containing(u'.')
 
4770
    def run(self, directory=u'.'):
 
4771
        b, relpath = Branch.open_containing(directory)
4736
4772
        if not b.unbind():
4737
4773
            raise errors.BzrCommandError('Local branch is not bound')
4738
4774
 
4784
4820
            b = control.open_branch()
4785
4821
 
4786
4822
        if tree is not None:
4787
 
            tree.lock_write()
4788
 
            self.add_cleanup(tree.unlock)
 
4823
            self.add_cleanup(tree.lock_write().unlock)
4789
4824
        else:
4790
 
            b.lock_write()
4791
 
            self.add_cleanup(b.unlock)
 
4825
            self.add_cleanup(b.lock_write().unlock)
4792
4826
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
4793
4827
 
4794
4828
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
4833
4867
            self.outf.write('The above revision(s) will be removed.\n')
4834
4868
 
4835
4869
        if not force:
4836
 
            if not ui.ui_factory.get_boolean('Are you sure'):
4837
 
                self.outf.write('Canceled')
 
4870
            if not ui.ui_factory.confirm_action(
 
4871
                    'Uncommit these revisions',
 
4872
                    'bzrlib.builtins.uncommit',
 
4873
                    {}):
 
4874
                self.outf.write('Canceled\n')
4838
4875
                return 0
4839
4876
 
4840
4877
        mutter('Uncommitting from {%s} to {%s}',
4846
4883
 
4847
4884
 
4848
4885
class cmd_break_lock(Command):
4849
 
    __doc__ = """Break a dead lock on a repository, branch or working directory.
 
4886
    __doc__ = """Break a dead lock.
 
4887
 
 
4888
    This command breaks a lock on a repository, branch, working directory or
 
4889
    config file.
4850
4890
 
4851
4891
    CAUTION: Locks should only be broken when you are sure that the process
4852
4892
    holding the lock has been stopped.
4857
4897
    :Examples:
4858
4898
        bzr break-lock
4859
4899
        bzr break-lock bzr+ssh://example.com/bzr/foo
 
4900
        bzr break-lock --conf ~/.bazaar
4860
4901
    """
 
4902
 
4861
4903
    takes_args = ['location?']
 
4904
    takes_options = [
 
4905
        Option('config',
 
4906
               help='LOCATION is the directory where the config lock is.'),
 
4907
        Option('force',
 
4908
            help='Do not ask for confirmation before breaking the lock.'),
 
4909
        ]
4862
4910
 
4863
 
    def run(self, location=None, show=False):
 
4911
    def run(self, location=None, config=False, force=False):
4864
4912
        if location is None:
4865
4913
            location = u'.'
4866
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
4867
 
        try:
4868
 
            control.break_lock()
4869
 
        except NotImplementedError:
4870
 
            pass
 
4914
        if force:
 
4915
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
 
4916
                None,
 
4917
                {'bzrlib.lockdir.break': True})
 
4918
        if config:
 
4919
            conf = _mod_config.LockableConfig(file_name=location)
 
4920
            conf.break_lock()
 
4921
        else:
 
4922
            control, relpath = bzrdir.BzrDir.open_containing(location)
 
4923
            try:
 
4924
                control.break_lock()
 
4925
            except NotImplementedError:
 
4926
                pass
4871
4927
 
4872
4928
 
4873
4929
class cmd_wait_until_signalled(Command):
4902
4958
                    'result in a dynamically allocated port.  The default port '
4903
4959
                    'depends on the protocol.',
4904
4960
               type=str),
4905
 
        Option('directory',
4906
 
               help='Serve contents of this directory.',
4907
 
               type=unicode),
 
4961
        custom_help('directory',
 
4962
               help='Serve contents of this directory.'),
4908
4963
        Option('allow-writes',
4909
4964
               help='By default the server is a readonly server.  Supplying '
4910
4965
                    '--allow-writes enables write access to the contents of '
4937
4992
 
4938
4993
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
4994
            protocol=None):
4940
 
        from bzrlib.transport import get_transport, transport_server_registry
 
4995
        from bzrlib import transport
4941
4996
        if directory is None:
4942
4997
            directory = os.getcwd()
4943
4998
        if protocol is None:
4944
 
            protocol = transport_server_registry.get()
 
4999
            protocol = transport.transport_server_registry.get()
4945
5000
        host, port = self.get_host_and_port(port)
4946
5001
        url = urlutils.local_path_to_url(directory)
4947
5002
        if not allow_writes:
4948
5003
            url = 'readonly+' + url
4949
 
        transport = get_transport(url)
4950
 
        protocol(transport, host, port, inet)
 
5004
        t = transport.get_transport(url)
 
5005
        protocol(t, host, port, inet)
4951
5006
 
4952
5007
 
4953
5008
class cmd_join(Command):
4959
5014
    not part of it.  (Such trees can be produced by "bzr split", but also by
4960
5015
    running "bzr branch" with the target inside a tree.)
4961
5016
 
4962
 
    The result is a combined tree, with the subtree no longer an independant
 
5017
    The result is a combined tree, with the subtree no longer an independent
4963
5018
    part.  This is marked as a merge of the subtree into the containing tree,
4964
5019
    and all history is preserved.
4965
5020
    """
5046
5101
    _see_also = ['send']
5047
5102
 
5048
5103
    takes_options = [
 
5104
        'directory',
5049
5105
        RegistryOption.from_kwargs('patch-type',
5050
5106
            'The type of patch to include in the directive.',
5051
5107
            title='Patch type',
5064
5120
    encoding_type = 'exact'
5065
5121
 
5066
5122
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
 
            sign=False, revision=None, mail_to=None, message=None):
 
5123
            sign=False, revision=None, mail_to=None, message=None,
 
5124
            directory=u'.'):
5068
5125
        from bzrlib.revision import ensure_null, NULL_REVISION
5069
5126
        include_patch, include_bundle = {
5070
5127
            'plain': (False, False),
5071
5128
            'diff': (True, False),
5072
5129
            'bundle': (True, True),
5073
5130
            }[patch_type]
5074
 
        branch = Branch.open('.')
 
5131
        branch = Branch.open(directory)
5075
5132
        stored_submit_branch = branch.get_submit_branch()
5076
5133
        if submit_branch is None:
5077
5134
            submit_branch = stored_submit_branch
5162
5219
    given, in which case it is sent to a file.
5163
5220
 
5164
5221
    Mail is sent using your preferred mail program.  This should be transparent
5165
 
    on Windows (it uses MAPI).  On Linux, it requires the xdg-email utility.
 
5222
    on Windows (it uses MAPI).  On Unix, it requires the xdg-email utility.
5166
5223
    If the preferred client can't be found (or used), your editor will be used.
5167
5224
 
5168
5225
    To use a specific mail program, set the mail_client configuration option.
5339
5396
        Option('delete',
5340
5397
            help='Delete this tag rather than placing it.',
5341
5398
            ),
5342
 
        Option('directory',
5343
 
            help='Branch in which to place the tag.',
5344
 
            short_name='d',
5345
 
            type=unicode,
5346
 
            ),
 
5399
        custom_help('directory',
 
5400
            help='Branch in which to place the tag.'),
5347
5401
        Option('force',
5348
5402
            help='Replace existing tags.',
5349
5403
            ),
5357
5411
            revision=None,
5358
5412
            ):
5359
5413
        branch, relpath = Branch.open_containing(directory)
5360
 
        branch.lock_write()
5361
 
        self.add_cleanup(branch.unlock)
 
5414
        self.add_cleanup(branch.lock_write().unlock)
5362
5415
        if delete:
5363
5416
            if tag_name is None:
5364
5417
                raise errors.BzrCommandError("No tag specified to delete.")
5365
5418
            branch.tags.delete_tag(tag_name)
5366
 
            self.outf.write('Deleted tag %s.\n' % tag_name)
 
5419
            note('Deleted tag %s.' % tag_name)
5367
5420
        else:
5368
5421
            if revision:
5369
5422
                if len(revision) != 1:
5381
5434
            if (not force) and branch.tags.has_tag(tag_name):
5382
5435
                raise errors.TagAlreadyExists(tag_name)
5383
5436
            branch.tags.set_tag(tag_name, revision_id)
5384
 
            self.outf.write('Created tag %s.\n' % tag_name)
 
5437
            note('Created tag %s.' % tag_name)
5385
5438
 
5386
5439
 
5387
5440
class cmd_tags(Command):
5392
5445
 
5393
5446
    _see_also = ['tag']
5394
5447
    takes_options = [
5395
 
        Option('directory',
5396
 
            help='Branch whose tags should be displayed.',
5397
 
            short_name='d',
5398
 
            type=unicode,
5399
 
            ),
 
5448
        custom_help('directory',
 
5449
            help='Branch whose tags should be displayed.'),
5400
5450
        RegistryOption.from_kwargs('sort',
5401
5451
            'Sort tags by different criteria.', title='Sorting',
5402
 
            alpha='Sort tags lexicographically (default).',
 
5452
            natural='Sort numeric substrings as numbers:'
 
5453
                    ' suitable for version numbers. (default)',
 
5454
            alpha='Sort tags lexicographically.',
5403
5455
            time='Sort tags chronologically.',
5404
5456
            ),
5405
5457
        'show-ids',
5409
5461
    @display_command
5410
5462
    def run(self,
5411
5463
            directory='.',
5412
 
            sort='alpha',
 
5464
            sort='natural',
5413
5465
            show_ids=False,
5414
5466
            revision=None,
5415
5467
            ):
5419
5471
        if not tags:
5420
5472
            return
5421
5473
 
5422
 
        branch.lock_read()
5423
 
        self.add_cleanup(branch.unlock)
 
5474
        self.add_cleanup(branch.lock_read().unlock)
5424
5475
        if revision:
5425
5476
            graph = branch.repository.get_graph()
5426
5477
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5428
5479
            # only show revisions between revid1 and revid2 (inclusive)
5429
5480
            tags = [(tag, revid) for tag, revid in tags if
5430
5481
                graph.is_between(revid, revid1, revid2)]
5431
 
        if sort == 'alpha':
 
5482
        if sort == 'natural':
 
5483
            def natural_sort_key(tag):
 
5484
                return [f(s) for f,s in 
 
5485
                        zip(itertools.cycle((unicode.lower,int)),
 
5486
                                            re.split('([0-9]+)', tag[0]))]
 
5487
            tags.sort(key=natural_sort_key)
 
5488
        elif sort == 'alpha':
5432
5489
            tags.sort()
5433
5490
        elif sort == 'time':
5434
5491
            timestamps = {}
5573
5630
    """
5574
5631
 
5575
5632
    takes_args = ['to_location?']
5576
 
    takes_options = [Option('force',
 
5633
    takes_options = ['directory',
 
5634
                     Option('force',
5577
5635
                        help='Switch even if local commits will be lost.'),
5578
5636
                     'revision',
5579
5637
                     Option('create-branch', short_name='b',
5582
5640
                    ]
5583
5641
 
5584
5642
    def run(self, to_location=None, force=False, create_branch=False,
5585
 
            revision=None):
 
5643
            revision=None, directory=u'.'):
5586
5644
        from bzrlib import switch
5587
 
        tree_location = '.'
 
5645
        tree_location = directory
5588
5646
        revision = _get_one_revision('switch', revision)
5589
5647
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5648
        if to_location is None:
5591
5649
            if revision is None:
5592
5650
                raise errors.BzrCommandError('You must supply either a'
5593
5651
                                             ' revision or a location')
5594
 
            to_location = '.'
 
5652
            to_location = tree_location
5595
5653
        try:
5596
5654
            branch = control_dir.open_branch()
5597
5655
            had_explicit_nick = branch.get_config().has_explicit_nickname()
5732
5790
            name=None,
5733
5791
            switch=None,
5734
5792
            ):
5735
 
        tree, file_list = tree_files(file_list, apply_view=False)
 
5793
        tree, file_list = WorkingTree.open_containing_paths(file_list,
 
5794
            apply_view=False)
5736
5795
        current_view, view_dict = tree.views.get_view_info()
5737
5796
        if name is None:
5738
5797
            name = current_view
5842
5901
            location = "."
5843
5902
        branch = Branch.open_containing(location)[0]
5844
5903
        branch.bzrdir.destroy_branch()
5845
 
        
 
5904
 
5846
5905
 
5847
5906
class cmd_shelve(Command):
5848
5907
    __doc__ = """Temporarily set aside some changes from the current tree.
5867
5926
 
5868
5927
    You can put multiple items on the shelf, and by default, 'unshelve' will
5869
5928
    restore the most recently shelved changes.
 
5929
 
 
5930
    For complicated changes, it is possible to edit the changes in a separate
 
5931
    editor program to decide what the file remaining in the working copy
 
5932
    should look like.  To do this, add the configuration option
 
5933
 
 
5934
        change_editor = PROGRAM @new_path @old_path
 
5935
 
 
5936
    where @new_path is replaced with the path of the new version of the 
 
5937
    file and @old_path is replaced with the path of the old version of 
 
5938
    the file.  The PROGRAM should save the new file with the desired 
 
5939
    contents of the file in the working tree.
 
5940
        
5870
5941
    """
5871
5942
 
5872
5943
    takes_args = ['file*']
5873
5944
 
5874
5945
    takes_options = [
 
5946
        'directory',
5875
5947
        'revision',
5876
5948
        Option('all', help='Shelve all changes.'),
5877
5949
        'message',
5883
5955
        Option('destroy',
5884
5956
               help='Destroy removed changes instead of shelving them.'),
5885
5957
    ]
5886
 
    _see_also = ['unshelve']
 
5958
    _see_also = ['unshelve', 'configuration']
5887
5959
 
5888
5960
    def run(self, revision=None, all=False, file_list=None, message=None,
5889
 
            writer=None, list=False, destroy=False):
 
5961
            writer=None, list=False, destroy=False, directory=None):
5890
5962
        if list:
5891
 
            return self.run_for_list()
 
5963
            return self.run_for_list(directory=directory)
5892
5964
        from bzrlib.shelf_ui import Shelver
5893
5965
        if writer is None:
5894
5966
            writer = bzrlib.option.diff_writer_registry.get()
5895
5967
        try:
5896
5968
            shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
 
                file_list, message, destroy=destroy)
 
5969
                file_list, message, destroy=destroy, directory=directory)
5898
5970
            try:
5899
5971
                shelver.run()
5900
5972
            finally:
5902
5974
        except errors.UserAbort:
5903
5975
            return 0
5904
5976
 
5905
 
    def run_for_list(self):
5906
 
        tree = WorkingTree.open_containing('.')[0]
5907
 
        tree.lock_read()
5908
 
        self.add_cleanup(tree.unlock)
 
5977
    def run_for_list(self, directory=None):
 
5978
        if directory is None:
 
5979
            directory = u'.'
 
5980
        tree = WorkingTree.open_containing(directory)[0]
 
5981
        self.add_cleanup(tree.lock_read().unlock)
5909
5982
        manager = tree.get_shelf_manager()
5910
5983
        shelves = manager.active_shelves()
5911
5984
        if len(shelves) == 0:
5929
6002
 
5930
6003
    takes_args = ['shelf_id?']
5931
6004
    takes_options = [
 
6005
        'directory',
5932
6006
        RegistryOption.from_kwargs(
5933
6007
            'action', help="The action to perform.",
5934
6008
            enum_switch=False, value_switches=True,
5942
6016
    ]
5943
6017
    _see_also = ['shelve']
5944
6018
 
5945
 
    def run(self, shelf_id=None, action='apply'):
 
6019
    def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
6020
        from bzrlib.shelf_ui import Unshelver
5947
 
        unshelver = Unshelver.from_args(shelf_id, action)
 
6021
        unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5948
6022
        try:
5949
6023
            unshelver.run()
5950
6024
        finally:
5966
6040
 
5967
6041
    To check what clean-tree will do, use --dry-run.
5968
6042
    """
5969
 
    takes_options = [Option('ignored', help='Delete all ignored files.'),
 
6043
    takes_options = ['directory',
 
6044
                     Option('ignored', help='Delete all ignored files.'),
5970
6045
                     Option('detritus', help='Delete conflict files, merge'
5971
6046
                            ' backups, and failed selftest dirs.'),
5972
6047
                     Option('unknown',
5975
6050
                            ' deleting them.'),
5976
6051
                     Option('force', help='Do not prompt before deleting.')]
5977
6052
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5978
 
            force=False):
 
6053
            force=False, directory=u'.'):
5979
6054
        from bzrlib.clean_tree import clean_tree
5980
6055
        if not (unknown or ignored or detritus):
5981
6056
            unknown = True
5982
6057
        if dry_run:
5983
6058
            force = True
5984
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
 
                   dry_run=dry_run, no_prompt=force)
 
6059
        clean_tree(directory, unknown=unknown, ignored=ignored,
 
6060
                   detritus=detritus, dry_run=dry_run, no_prompt=force)
5986
6061
 
5987
6062
 
5988
6063
class cmd_reference(Command):
6037
6112
    # be only called once.
6038
6113
    for (name, aliases, module_name) in [
6039
6114
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
 
6115
        ('cmd_config', [], 'bzrlib.config'),
6040
6116
        ('cmd_dpush', [], 'bzrlib.foreign'),
6041
6117
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6042
6118
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6043
6119
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6044
6120
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
 
6121
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6045
6122
        ]:
6046
6123
        builtin_command_registry.register_lazy(name, aliases, module_name)