/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to bzrlib/builtins.py

  • Committer: John Arbash Meinel
  • Date: 2011-04-07 10:36:24 UTC
  • mfrom: (5764 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5766.
  • Revision ID: john@arbash-meinel.com-20110407103624-n76g6tjeqmznwdcd
Merge bzr.dev 5764 to resolve release-notes (aka NEWS) conflicts

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005-2010 Canonical Ltd
 
1
# Copyright (C) 2005-2011 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
20
20
 
21
21
from bzrlib.lazy_import import lazy_import
22
22
lazy_import(globals(), """
23
 
import codecs
24
23
import cStringIO
25
24
import sys
26
25
import time
33
32
    bzrdir,
34
33
    directory_service,
35
34
    delta,
36
 
    config,
 
35
    config as _mod_config,
37
36
    errors,
38
37
    globbing,
39
38
    hooks,
75
74
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
76
75
 
77
76
 
 
77
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
78
78
def tree_files(file_list, default_branch=u'.', canonicalize=True,
79
79
    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]))
 
80
    return internal_tree_files(file_list, default_branch, canonicalize,
 
81
        apply_view)
86
82
 
87
83
 
88
84
def tree_files_for_add(file_list):
152
148
 
153
149
# XXX: Bad function name; should possibly also be a class method of
154
150
# WorkingTree rather than a function.
 
151
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
155
152
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
156
153
    apply_view=True):
157
154
    """Convert command-line paths to a WorkingTree and relative paths.
158
155
 
 
156
    Deprecated: use WorkingTree.open_containing_paths instead.
 
157
 
159
158
    This is typically used for command-line processors that take one or
160
159
    more filenames, and infer the workingtree that contains them.
161
160
 
171
170
 
172
171
    :return: workingtree, [relative_paths]
173
172
    """
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
 
173
    return WorkingTree.open_containing_paths(
 
174
        file_list, default_directory='.',
 
175
        canonicalize=True,
 
176
        apply_view=True)
221
177
 
222
178
 
223
179
def _get_view_info_for_change_reporter(tree):
294
250
    To skip the display of pending merge information altogether, use
295
251
    the no-pending option or specify a file/directory.
296
252
 
297
 
    If a revision argument is given, the status is calculated against
298
 
    that revision, or between two revisions if two are provided.
 
253
    To compare the working directory to a specific revision, pass a
 
254
    single revision to the revision argument.
 
255
 
 
256
    To see which files have changed in a specific revision, or between
 
257
    two revisions, pass a revision range to the revision argument.
 
258
    This will produce the same results as calling 'bzr diff --summarize'.
299
259
    """
300
260
 
301
261
    # TODO: --no-recurse, --recurse options
323
283
            raise errors.BzrCommandError('bzr status --revision takes exactly'
324
284
                                         ' one or two revision specifiers')
325
285
 
326
 
        tree, relfile_list = tree_files(file_list)
 
286
        tree, relfile_list = WorkingTree.open_containing_paths(file_list)
327
287
        # Avoid asking for specific files when that is not needed.
328
288
        if relfile_list == ['']:
329
289
            relfile_list = None
368
328
        if revision_id is None and revision is None:
369
329
            raise errors.BzrCommandError('You must supply either'
370
330
                                         ' --revision or a revision_id')
371
 
        b = WorkingTree.open_containing(directory)[0].branch
 
331
 
 
332
        b = bzrdir.BzrDir.open_containing_tree_or_branch(directory)[1]
372
333
 
373
334
        revisions = b.repository.revisions
374
335
        if revisions is None:
452
413
                self.outf.write(page_bytes[:header_end])
453
414
                page_bytes = data
454
415
            self.outf.write('\nPage %d\n' % (page_idx,))
455
 
            decomp_bytes = zlib.decompress(page_bytes)
456
 
            self.outf.write(decomp_bytes)
457
 
            self.outf.write('\n')
 
416
            if len(page_bytes) == 0:
 
417
                self.outf.write('(empty)\n');
 
418
            else:
 
419
                decomp_bytes = zlib.decompress(page_bytes)
 
420
                self.outf.write(decomp_bytes)
 
421
                self.outf.write('\n')
458
422
 
459
423
    def _dump_entries(self, trans, basename):
460
424
        try:
491
455
    takes_options = [
492
456
        Option('force',
493
457
               help='Remove the working tree even if it has '
494
 
                    'uncommitted changes.'),
 
458
                    'uncommitted or shelved changes.'),
495
459
        ]
496
460
 
497
461
    def run(self, location_list, force=False):
511
475
            if not force:
512
476
                if (working.has_changes()):
513
477
                    raise errors.UncommittedChanges(working)
 
478
                if working.get_shelf_manager().last_shelf() is not None:
 
479
                    raise errors.ShelvedChanges(working)
514
480
 
515
481
            if working.user_url != working.branch.user_url:
516
482
                raise errors.BzrCommandError("You cannot remove the working tree"
519
485
            d.destroy_workingtree()
520
486
 
521
487
 
 
488
class cmd_repair_workingtree(Command):
 
489
    __doc__ = """Reset the working tree state file.
 
490
 
 
491
    This is not meant to be used normally, but more as a way to recover from
 
492
    filesystem corruption, etc. This rebuilds the working inventory back to a
 
493
    'known good' state. Any new modifications (adding a file, renaming, etc)
 
494
    will be lost, though modified files will still be detected as such.
 
495
 
 
496
    Most users will want something more like "bzr revert" or "bzr update"
 
497
    unless the state file has become corrupted.
 
498
 
 
499
    By default this attempts to recover the current state by looking at the
 
500
    headers of the state file. If the state file is too corrupted to even do
 
501
    that, you can supply --revision to force the state of the tree.
 
502
    """
 
503
 
 
504
    takes_options = ['revision', 'directory',
 
505
        Option('force',
 
506
               help='Reset the tree even if it doesn\'t appear to be'
 
507
                    ' corrupted.'),
 
508
    ]
 
509
    hidden = True
 
510
 
 
511
    def run(self, revision=None, directory='.', force=False):
 
512
        tree, _ = WorkingTree.open_containing(directory)
 
513
        self.add_cleanup(tree.lock_tree_write().unlock)
 
514
        if not force:
 
515
            try:
 
516
                tree.check_state()
 
517
            except errors.BzrError:
 
518
                pass # There seems to be a real error here, so we'll reset
 
519
            else:
 
520
                # Refuse
 
521
                raise errors.BzrCommandError(
 
522
                    'The tree does not appear to be corrupt. You probably'
 
523
                    ' want "bzr revert" instead. Use "--force" if you are'
 
524
                    ' sure you want to reset the working tree.')
 
525
        if revision is None:
 
526
            revision_ids = None
 
527
        else:
 
528
            revision_ids = [r.as_revision_id(tree.branch) for r in revision]
 
529
        try:
 
530
            tree.reset_state(revision_ids)
 
531
        except errors.BzrError, e:
 
532
            if revision_ids is None:
 
533
                extra = (', the header appears corrupt, try passing -r -1'
 
534
                         ' to set the state to the last commit')
 
535
            else:
 
536
                extra = ''
 
537
            raise errors.BzrCommandError('failed to reset the tree state'
 
538
                                         + extra)
 
539
 
 
540
 
522
541
class cmd_revno(Command):
523
542
    __doc__ = """Show current revision number.
524
543
 
759
778
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
760
779
 
761
780
        revision = _get_one_revision('inventory', revision)
762
 
        work_tree, file_list = tree_files(file_list)
 
781
        work_tree, file_list = WorkingTree.open_containing_paths(file_list)
763
782
        self.add_cleanup(work_tree.lock_read().unlock)
764
783
        if revision is not None:
765
784
            tree = revision.as_tree(work_tree.branch)
830
849
            names_list = []
831
850
        if len(names_list) < 2:
832
851
            raise errors.BzrCommandError("missing file argument")
833
 
        tree, rel_names = tree_files(names_list, canonicalize=False)
 
852
        tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
834
853
        self.add_cleanup(tree.lock_tree_write().unlock)
835
854
        self._run(tree, names_list, rel_names, after)
836
855
 
841
860
        if after:
842
861
            raise errors.BzrCommandError('--after cannot be specified with'
843
862
                                         ' --auto.')
844
 
        work_tree, file_list = tree_files(names_list, default_branch='.')
 
863
        work_tree, file_list = WorkingTree.open_containing_paths(
 
864
            names_list, default_directory='.')
845
865
        self.add_cleanup(work_tree.lock_tree_write().unlock)
846
866
        rename_map.RenameMap.guess_renames(work_tree, dry_run)
847
867
 
964
984
                 "branch.  Local pulls are not applied to "
965
985
                 "the master branch."
966
986
            ),
 
987
        Option('show-base',
 
988
            help="Show base revision text in conflicts.")
967
989
        ]
968
990
    takes_args = ['location?']
969
991
    encoding_type = 'replace'
970
992
 
971
993
    def run(self, location=None, remember=False, overwrite=False,
972
994
            revision=None, verbose=False,
973
 
            directory=None, local=False):
 
995
            directory=None, local=False,
 
996
            show_base=False):
974
997
        # FIXME: too much stuff is in the command class
975
998
        revision_id = None
976
999
        mergeable = None
985
1008
            branch_to = Branch.open_containing(directory)[0]
986
1009
            self.add_cleanup(branch_to.lock_write().unlock)
987
1010
 
 
1011
        if tree_to is None and show_base:
 
1012
            raise errors.BzrCommandError("Need working tree for --show-base.")
 
1013
 
988
1014
        if local and not branch_to.get_bound_location():
989
1015
            raise errors.LocalRequiresBoundBranch()
990
1016
 
1035
1061
                view_info=view_info)
1036
1062
            result = tree_to.pull(
1037
1063
                branch_from, overwrite, revision_id, change_reporter,
1038
 
                possible_transports=possible_transports, local=local)
 
1064
                possible_transports=possible_transports, local=local,
 
1065
                show_base=show_base)
1039
1066
        else:
1040
1067
            result = branch_to.pull(
1041
1068
                branch_from, overwrite, revision_id, local=local)
1045
1072
            log.show_branch_change(
1046
1073
                branch_to, self.outf, result.old_revno,
1047
1074
                result.old_revid)
 
1075
        if getattr(result, 'tag_conflicts', None):
 
1076
            return 1
 
1077
        else:
 
1078
            return 0
1048
1079
 
1049
1080
 
1050
1081
class cmd_push(Command):
1097
1128
        Option('strict',
1098
1129
               help='Refuse to push if there are uncommitted changes in'
1099
1130
               ' the working tree, --no-strict disables the check.'),
 
1131
        Option('no-tree',
 
1132
               help="Don't populate the working tree, even for protocols"
 
1133
               " that support it."),
1100
1134
        ]
1101
1135
    takes_args = ['location?']
1102
1136
    encoding_type = 'replace'
1104
1138
    def run(self, location=None, remember=False, overwrite=False,
1105
1139
        create_prefix=False, verbose=False, revision=None,
1106
1140
        use_existing_dir=False, directory=None, stacked_on=None,
1107
 
        stacked=False, strict=None):
 
1141
        stacked=False, strict=None, no_tree=False):
1108
1142
        from bzrlib.push import _show_push_branch
1109
1143
 
1110
1144
        if directory is None:
1156
1190
        _show_push_branch(br_from, revision_id, location, self.outf,
1157
1191
            verbose=verbose, overwrite=overwrite, remember=remember,
1158
1192
            stacked_on=stacked_on, create_prefix=create_prefix,
1159
 
            use_existing_dir=use_existing_dir)
 
1193
            use_existing_dir=use_existing_dir, no_tree=no_tree)
1160
1194
 
1161
1195
 
1162
1196
class cmd_branch(Command):
1175
1209
 
1176
1210
    _see_also = ['checkout']
1177
1211
    takes_args = ['from_location', 'to_location?']
1178
 
    takes_options = ['revision', Option('hardlink',
1179
 
        help='Hard-link working tree files where possible.'),
 
1212
    takes_options = ['revision',
 
1213
        Option('hardlink', help='Hard-link working tree files where possible.'),
 
1214
        Option('files-from', type=str,
 
1215
               help="Get file contents from this tree."),
1180
1216
        Option('no-tree',
1181
1217
            help="Create a branch without a working-tree."),
1182
1218
        Option('switch',
1200
1236
 
1201
1237
    def run(self, from_location, to_location=None, revision=None,
1202
1238
            hardlink=False, stacked=False, standalone=False, no_tree=False,
1203
 
            use_existing_dir=False, switch=False, bind=False):
 
1239
            use_existing_dir=False, switch=False, bind=False,
 
1240
            files_from=None):
1204
1241
        from bzrlib import switch as _mod_switch
1205
1242
        from bzrlib.tag import _merge_tags_if_possible
1206
1243
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1207
1244
            from_location)
 
1245
        if not (hardlink or files_from):
 
1246
            # accelerator_tree is usually slower because you have to read N
 
1247
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1248
            # explicitly request it
 
1249
            accelerator_tree = None
 
1250
        if files_from is not None and files_from != from_location:
 
1251
            accelerator_tree = WorkingTree.open(files_from)
1208
1252
        revision = _get_one_revision('branch', revision)
1209
1253
        self.add_cleanup(br_from.lock_read().unlock)
1210
1254
        if revision is not None:
1317
1361
            to_location = branch_location
1318
1362
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1319
1363
            branch_location)
 
1364
        if not (hardlink or files_from):
 
1365
            # accelerator_tree is usually slower because you have to read N
 
1366
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1367
            # explicitly request it
 
1368
            accelerator_tree = None
1320
1369
        revision = _get_one_revision('checkout', revision)
1321
 
        if files_from is not None:
 
1370
        if files_from is not None and files_from != branch_location:
1322
1371
            accelerator_tree = WorkingTree.open(files_from)
1323
1372
        if revision is not None:
1324
1373
            revision_id = revision.as_revision_id(source)
1336
1385
            except errors.NoWorkingTree:
1337
1386
                source.bzrdir.create_workingtree(revision_id)
1338
1387
                return
1339
 
 
1340
 
        if not lightweight:
1341
 
            message = ('Copying history to "%s". '
1342
 
                'To checkout without local history use --lightweight.' % to_location)
1343
 
            ui.ui_factory.show_message(message)
1344
1388
        source.create_checkout(to_location, revision_id, lightweight,
1345
1389
                               accelerator_tree, hardlink)
1346
1390
 
1385
1429
    If you want to discard your local changes, you can just do a
1386
1430
    'bzr revert' instead of 'bzr commit' after the update.
1387
1431
 
 
1432
    If you want to restore a file that has been removed locally, use
 
1433
    'bzr revert' instead of 'bzr update'.
 
1434
 
1388
1435
    If the tree's branch is bound to a master branch, it will also update
1389
1436
    the branch from the master.
1390
1437
    """
1391
1438
 
1392
1439
    _see_also = ['pull', 'working-trees', 'status-flags']
1393
1440
    takes_args = ['dir?']
1394
 
    takes_options = ['revision']
 
1441
    takes_options = ['revision',
 
1442
                     Option('show-base',
 
1443
                            help="Show base revision text in conflicts."),
 
1444
                     ]
1395
1445
    aliases = ['up']
1396
1446
 
1397
 
    def run(self, dir='.', revision=None):
 
1447
    def run(self, dir='.', revision=None, show_base=None):
1398
1448
        if revision is not None and len(revision) != 1:
1399
1449
            raise errors.BzrCommandError(
1400
1450
                        "bzr update --revision takes exactly one revision")
1440
1490
                change_reporter,
1441
1491
                possible_transports=possible_transports,
1442
1492
                revision=revision_id,
1443
 
                old_tip=old_tip)
 
1493
                old_tip=old_tip,
 
1494
                show_base=show_base)
1444
1495
        except errors.NoSuchRevision, e:
1445
1496
            raise errors.BzrCommandError(
1446
1497
                                  "branch has no revision %s\n"
1508
1559
class cmd_remove(Command):
1509
1560
    __doc__ = """Remove files or directories.
1510
1561
 
1511
 
    This makes bzr stop tracking changes to the specified files. bzr will delete
1512
 
    them if they can easily be recovered using revert. If no options or
1513
 
    parameters are given bzr will scan for files that are being tracked by bzr
1514
 
    but missing in your tree and stop tracking them for you.
 
1562
    This makes Bazaar stop tracking changes to the specified files. Bazaar will
 
1563
    delete them if they can easily be recovered using revert otherwise they
 
1564
    will be backed up (adding an extention of the form .~#~). If no options or
 
1565
    parameters are given Bazaar will scan for files that are being tracked by
 
1566
    Bazaar but missing in your tree and stop tracking them for you.
1515
1567
    """
1516
1568
    takes_args = ['file*']
1517
1569
    takes_options = ['verbose',
1519
1571
        RegistryOption.from_kwargs('file-deletion-strategy',
1520
1572
            'The file deletion mode to be used.',
1521
1573
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1522
 
            safe='Only delete files if they can be'
1523
 
                 ' safely recovered (default).',
 
1574
            safe='Backup changed files (default).',
1524
1575
            keep='Delete from bzr but leave the working copy.',
 
1576
            no_backup='Don\'t backup changed files.',
1525
1577
            force='Delete all the specified files, even if they can not be '
1526
 
                'recovered and even if they are non-empty directories.')]
 
1578
                'recovered and even if they are non-empty directories. '
 
1579
                '(deprecated, use no-backup)')]
1527
1580
    aliases = ['rm', 'del']
1528
1581
    encoding_type = 'replace'
1529
1582
 
1530
1583
    def run(self, file_list, verbose=False, new=False,
1531
1584
        file_deletion_strategy='safe'):
1532
 
        tree, file_list = tree_files(file_list)
 
1585
        if file_deletion_strategy == 'force':
 
1586
            note("(The --force option is deprecated, rather use --no-backup "
 
1587
                "in future.)")
 
1588
            file_deletion_strategy = 'no-backup'
 
1589
 
 
1590
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1533
1591
 
1534
1592
        if file_list is not None:
1535
1593
            file_list = [f for f in file_list]
1555
1613
            file_deletion_strategy = 'keep'
1556
1614
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1557
1615
            keep_files=file_deletion_strategy=='keep',
1558
 
            force=file_deletion_strategy=='force')
 
1616
            force=(file_deletion_strategy=='no-backup'))
1559
1617
 
1560
1618
 
1561
1619
class cmd_file_id(Command):
1623
1681
 
1624
1682
    _see_also = ['check']
1625
1683
    takes_args = ['branch?']
 
1684
    takes_options = [
 
1685
        Option('canonicalize-chks',
 
1686
               help='Make sure CHKs are in canonical form (repairs '
 
1687
                    'bug 522637).',
 
1688
               hidden=True),
 
1689
        ]
1626
1690
 
1627
 
    def run(self, branch="."):
 
1691
    def run(self, branch=".", canonicalize_chks=False):
1628
1692
        from bzrlib.reconcile import reconcile
1629
1693
        dir = bzrdir.BzrDir.open(branch)
1630
 
        reconcile(dir)
 
1694
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1631
1695
 
1632
1696
 
1633
1697
class cmd_revision_history(Command):
1710
1774
                ),
1711
1775
         Option('append-revisions-only',
1712
1776
                help='Never change revnos or the existing log.'
1713
 
                '  Append revisions to it only.')
 
1777
                '  Append revisions to it only.'),
 
1778
         Option('no-tree',
 
1779
                'Create a branch without a working tree.')
1714
1780
         ]
1715
1781
    def run(self, location=None, format=None, append_revisions_only=False,
1716
 
            create_prefix=False):
 
1782
            create_prefix=False, no_tree=False):
1717
1783
        if format is None:
1718
1784
            format = bzrdir.format_registry.make_bzrdir('default')
1719
1785
        if location is None:
1742
1808
        except errors.NotBranchError:
1743
1809
            # really a NotBzrDir error...
1744
1810
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
1811
            if no_tree:
 
1812
                force_new_tree = False
 
1813
            else:
 
1814
                force_new_tree = None
1745
1815
            branch = create_branch(to_transport.base, format=format,
1746
 
                                   possible_transports=[to_transport])
 
1816
                                   possible_transports=[to_transport],
 
1817
                                   force_new_tree=force_new_tree)
1747
1818
            a_bzrdir = branch.bzrdir
1748
1819
        else:
1749
1820
            from bzrlib.transport.local import LocalTransport
1753
1824
                        raise errors.BranchExistsWithoutWorkingTree(location)
1754
1825
                raise errors.AlreadyBranchError(location)
1755
1826
            branch = a_bzrdir.create_branch()
1756
 
            a_bzrdir.create_workingtree()
 
1827
            if not no_tree:
 
1828
                a_bzrdir.create_workingtree()
1757
1829
        if append_revisions_only:
1758
1830
            try:
1759
1831
                branch.set_append_revisions_only(True)
1853
1925
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1854
1926
    produces patches suitable for "patch -p1".
1855
1927
 
 
1928
    Note that when using the -r argument with a range of revisions, the
 
1929
    differences are computed between the two specified revisions.  That
 
1930
    is, the command does not show the changes introduced by the first 
 
1931
    revision in the range.  This differs from the interpretation of 
 
1932
    revision ranges used by "bzr log" which includes the first revision
 
1933
    in the range.
 
1934
 
1856
1935
    :Exit values:
1857
1936
        1 - changed
1858
1937
        2 - unrepresentable changes
1876
1955
 
1877
1956
            bzr diff -r1..3 xxx
1878
1957
 
1879
 
        To see the changes introduced in revision X::
 
1958
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1959
 
 
1960
            bzr diff -c2
 
1961
 
 
1962
        To see the changes introduced by revision X::
1880
1963
        
1881
1964
            bzr diff -cX
1882
1965
 
1886
1969
 
1887
1970
            bzr diff -r<chosen_parent>..X
1888
1971
 
1889
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1972
        The changes between the current revision and the previous revision
 
1973
        (equivalent to -c-1 and -r-2..-1)
1890
1974
 
1891
 
            bzr diff -c2
 
1975
            bzr diff -r-2..
1892
1976
 
1893
1977
        Show just the differences for file NEWS::
1894
1978
 
1909
1993
        Same as 'bzr diff' but prefix paths with old/ and new/::
1910
1994
 
1911
1995
            bzr diff --prefix old/:new/
 
1996
            
 
1997
        Show the differences using a custom diff program with options::
 
1998
        
 
1999
            bzr diff --using /usr/bin/diff --diff-options -wu
1912
2000
    """
1913
2001
    _see_also = ['status']
1914
2002
    takes_args = ['file*']
1934
2022
            type=unicode,
1935
2023
            ),
1936
2024
        RegistryOption('format',
 
2025
            short_name='F',
1937
2026
            help='Diff format to use.',
1938
2027
            lazy_registry=('bzrlib.diff', 'format_registry'),
1939
 
            value_switches=False, title='Diff format'),
 
2028
            title='Diff format'),
1940
2029
        ]
1941
2030
    aliases = ['di', 'dif']
1942
2031
    encoding_type = 'exact'
1973
2062
         old_branch, new_branch,
1974
2063
         specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1975
2064
            file_list, revision, old, new, self.add_cleanup, apply_view=True)
 
2065
        # GNU diff on Windows uses ANSI encoding for filenames
 
2066
        path_encoding = osutils.get_diff_header_encoding()
1976
2067
        return show_diff_trees(old_tree, new_tree, sys.stdout,
1977
2068
                               specific_files=specific_files,
1978
2069
                               external_diff_options=diff_options,
1979
2070
                               old_label=old_label, new_label=new_label,
1980
 
                               extra_trees=extra_trees, using=using,
 
2071
                               extra_trees=extra_trees,
 
2072
                               path_encoding=path_encoding,
 
2073
                               using=using,
1981
2074
                               format_cls=format)
1982
2075
 
1983
2076
 
2019
2112
    @display_command
2020
2113
    def run(self, null=False, directory=u'.'):
2021
2114
        tree = WorkingTree.open_containing(directory)[0]
 
2115
        self.add_cleanup(tree.lock_read().unlock)
2022
2116
        td = tree.changes_from(tree.basis_tree())
 
2117
        self.cleanup_now()
2023
2118
        for path, id, kind, text_modified, meta_modified in td.modified:
2024
2119
            if null:
2025
2120
                self.outf.write(path + '\0')
2655
2750
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2656
2751
    precedence over the '!' exception patterns.
2657
2752
 
2658
 
    Note: ignore patterns containing shell wildcards must be quoted from
2659
 
    the shell on Unix.
 
2753
    :Notes: 
 
2754
        
 
2755
    * Ignore patterns containing shell wildcards must be quoted from
 
2756
      the shell on Unix.
 
2757
 
 
2758
    * Ignore patterns starting with "#" act as comments in the ignore file.
 
2759
      To ignore patterns that begin with that character, use the "RE:" prefix.
2660
2760
 
2661
2761
    :Examples:
2662
2762
        Ignore the top level Makefile::
2671
2771
 
2672
2772
            bzr ignore "!special.class"
2673
2773
 
 
2774
        Ignore files whose name begins with the "#" character::
 
2775
 
 
2776
            bzr ignore "RE:^#"
 
2777
 
2674
2778
        Ignore .o files under the lib directory::
2675
2779
 
2676
2780
            bzr ignore "lib/**/*.o"
2684
2788
            bzr ignore "RE:(?!debian/).*"
2685
2789
        
2686
2790
        Ignore everything except the "local" toplevel directory,
2687
 
        but always ignore "*~" autosave files, even under local/::
 
2791
        but always ignore autosave files ending in ~, even under local/::
2688
2792
        
2689
2793
            bzr ignore "*"
2690
2794
            bzr ignore "!./local"
2711
2815
                "NAME_PATTERN or --default-rules.")
2712
2816
        name_pattern_list = [globbing.normalize_pattern(p)
2713
2817
                             for p in name_pattern_list]
 
2818
        bad_patterns = ''
 
2819
        for p in name_pattern_list:
 
2820
            if not globbing.Globster.is_pattern_valid(p):
 
2821
                bad_patterns += ('\n  %s' % p)
 
2822
        if bad_patterns:
 
2823
            msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
 
2824
            ui.ui_factory.show_error(msg)
 
2825
            raise errors.InvalidPattern('')
2714
2826
        for name_pattern in name_pattern_list:
2715
2827
            if (name_pattern[0] == '/' or
2716
2828
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2720
2832
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2721
2833
        ignored = globbing.Globster(name_pattern_list)
2722
2834
        matches = []
2723
 
        tree.lock_read()
 
2835
        self.add_cleanup(tree.lock_read().unlock)
2724
2836
        for entry in tree.list_files():
2725
2837
            id = entry[3]
2726
2838
            if id is not None:
2727
2839
                filename = entry[0]
2728
2840
                if ignored.match(filename):
2729
2841
                    matches.append(filename)
2730
 
        tree.unlock()
2731
2842
        if len(matches) > 0:
2732
2843
            self.outf.write("Warning: the following files are version controlled and"
2733
2844
                  " match your ignore pattern:\n%s"
2811
2922
         zip                          .zip
2812
2923
      =================       =========================
2813
2924
    """
 
2925
    encoding = 'exact'
2814
2926
    takes_args = ['dest', 'branch_or_subdir?']
2815
2927
    takes_options = ['directory',
2816
2928
        Option('format',
2994
3106
      to trigger updates to external systems like bug trackers. The --fixes
2995
3107
      option can be used to record the association between a revision and
2996
3108
      one or more bugs. See ``bzr help bugs`` for details.
2997
 
 
2998
 
      A selective commit may fail in some cases where the committed
2999
 
      tree would be invalid. Consider::
3000
 
  
3001
 
        bzr init foo
3002
 
        mkdir foo/bar
3003
 
        bzr add foo/bar
3004
 
        bzr commit foo -m "committing foo"
3005
 
        bzr mv foo/bar foo/baz
3006
 
        mkdir foo/bar
3007
 
        bzr add foo/bar
3008
 
        bzr commit foo/bar -m "committing bar but not baz"
3009
 
  
3010
 
      In the example above, the last commit will fail by design. This gives
3011
 
      the user the opportunity to decide whether they want to commit the
3012
 
      rename at the same time, separately first, or not at all. (As a general
3013
 
      rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3014
3109
    """
3015
 
    # TODO: Run hooks on tree to-be-committed, and after commit.
3016
 
 
3017
 
    # TODO: Strict commit that fails if there are deleted files.
3018
 
    #       (what does "deleted files" mean ??)
3019
 
 
3020
 
    # TODO: Give better message for -s, --summary, used by tla people
3021
 
 
3022
 
    # XXX: verbose currently does nothing
3023
3110
 
3024
3111
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3025
3112
    takes_args = ['selected*']
3101
3188
                raise errors.BzrCommandError(
3102
3189
                    "Could not parse --commit-time: " + str(e))
3103
3190
 
3104
 
        # TODO: Need a blackbox test for invoking the external editor; may be
3105
 
        # slightly problematic to run this cross-platform.
3106
 
 
3107
 
        # TODO: do more checks that the commit will succeed before
3108
 
        # spending the user's valuable time typing a commit message.
3109
 
 
3110
3191
        properties = {}
3111
3192
 
3112
 
        tree, selected_list = tree_files(selected_list)
 
3193
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3113
3194
        if selected_list == ['']:
3114
3195
            # workaround - commit of root of tree should be exactly the same
3115
3196
            # as just default commit in that tree, and succeed even though
3150
3231
        def get_message(commit_obj):
3151
3232
            """Callback to get commit message"""
3152
3233
            if file:
3153
 
                my_message = codecs.open(
3154
 
                    file, 'rt', osutils.get_user_encoding()).read()
 
3234
                f = open(file)
 
3235
                try:
 
3236
                    my_message = f.read().decode(osutils.get_user_encoding())
 
3237
                finally:
 
3238
                    f.close()
3155
3239
            elif message is not None:
3156
3240
                my_message = message
3157
3241
            else:
3186
3270
                        reporter=None, verbose=verbose, revprops=properties,
3187
3271
                        authors=author, timestamp=commit_stamp,
3188
3272
                        timezone=offset,
3189
 
                        exclude=safe_relpath_files(tree, exclude))
 
3273
                        exclude=tree.safe_relpath_files(exclude))
3190
3274
        except PointlessCommit:
3191
3275
            raise errors.BzrCommandError("No changes to commit."
3192
3276
                              " Use --unchanged to commit anyhow.")
3276
3360
 
3277
3361
 
3278
3362
class cmd_upgrade(Command):
3279
 
    __doc__ = """Upgrade branch storage to current format.
3280
 
 
3281
 
    The check command or bzr developers may sometimes advise you to run
3282
 
    this command. When the default format has changed you may also be warned
3283
 
    during other operations to upgrade.
 
3363
    __doc__ = """Upgrade a repository, branch or working tree to a newer format.
 
3364
 
 
3365
    When the default format has changed after a major new release of
 
3366
    Bazaar, you may be informed during certain operations that you
 
3367
    should upgrade. Upgrading to a newer format may improve performance
 
3368
    or make new features available. It may however limit interoperability
 
3369
    with older repositories or with older versions of Bazaar.
 
3370
 
 
3371
    If you wish to upgrade to a particular format rather than the
 
3372
    current default, that can be specified using the --format option.
 
3373
    As a consequence, you can use the upgrade command this way to
 
3374
    "downgrade" to an earlier format, though some conversions are
 
3375
    a one way process (e.g. changing from the 1.x default to the
 
3376
    2.x default) so downgrading is not always possible.
 
3377
 
 
3378
    A backup.bzr.~#~ directory is created at the start of the conversion
 
3379
    process (where # is a number). By default, this is left there on
 
3380
    completion. If the conversion fails, delete the new .bzr directory
 
3381
    and rename this one back in its place. Use the --clean option to ask
 
3382
    for the backup.bzr directory to be removed on successful conversion.
 
3383
    Alternatively, you can delete it by hand if everything looks good
 
3384
    afterwards.
 
3385
 
 
3386
    If the location given is a shared repository, dependent branches
 
3387
    are also converted provided the repository converts successfully.
 
3388
    If the conversion of a branch fails, remaining branches are still
 
3389
    tried.
 
3390
 
 
3391
    For more information on upgrades, see the Bazaar Upgrade Guide,
 
3392
    http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3284
3393
    """
3285
3394
 
3286
 
    _see_also = ['check']
 
3395
    _see_also = ['check', 'reconcile', 'formats']
3287
3396
    takes_args = ['url?']
3288
3397
    takes_options = [
3289
 
                    RegistryOption('format',
3290
 
                        help='Upgrade to a specific format.  See "bzr help'
3291
 
                             ' formats" for details.',
3292
 
                        lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3293
 
                        converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3294
 
                        value_switches=True, title='Branch format'),
3295
 
                    ]
 
3398
        RegistryOption('format',
 
3399
            help='Upgrade to a specific format.  See "bzr help'
 
3400
                 ' formats" for details.',
 
3401
            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
 
3402
            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
 
3403
            value_switches=True, title='Branch format'),
 
3404
        Option('clean',
 
3405
            help='Remove the backup.bzr directory if successful.'),
 
3406
        Option('dry-run',
 
3407
            help="Show what would be done, but don't actually do anything."),
 
3408
    ]
3296
3409
 
3297
 
    def run(self, url='.', format=None):
 
3410
    def run(self, url='.', format=None, clean=False, dry_run=False):
3298
3411
        from bzrlib.upgrade import upgrade
3299
 
        upgrade(url, format)
 
3412
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
 
3413
        if exceptions:
 
3414
            if len(exceptions) == 1:
 
3415
                # Compatibility with historical behavior
 
3416
                raise exceptions[0]
 
3417
            else:
 
3418
                return 3
3300
3419
 
3301
3420
 
3302
3421
class cmd_whoami(Command):
3311
3430
 
3312
3431
            bzr whoami "Frank Chu <fchu@example.com>"
3313
3432
    """
3314
 
    takes_options = [ Option('email',
 
3433
    takes_options = [ 'directory',
 
3434
                      Option('email',
3315
3435
                             help='Display email address only.'),
3316
3436
                      Option('branch',
3317
3437
                             help='Set identity for the current branch instead of '
3321
3441
    encoding_type = 'replace'
3322
3442
 
3323
3443
    @display_command
3324
 
    def run(self, email=False, branch=False, name=None):
 
3444
    def run(self, email=False, branch=False, name=None, directory=None):
3325
3445
        if name is None:
3326
 
            # use branch if we're inside one; otherwise global config
3327
 
            try:
3328
 
                c = Branch.open_containing('.')[0].get_config()
3329
 
            except errors.NotBranchError:
3330
 
                c = config.GlobalConfig()
 
3446
            if directory is None:
 
3447
                # use branch if we're inside one; otherwise global config
 
3448
                try:
 
3449
                    c = Branch.open_containing(u'.')[0].get_config()
 
3450
                except errors.NotBranchError:
 
3451
                    c = _mod_config.GlobalConfig()
 
3452
            else:
 
3453
                c = Branch.open(directory).get_config()
3331
3454
            if email:
3332
3455
                self.outf.write(c.user_email() + '\n')
3333
3456
            else:
3334
3457
                self.outf.write(c.username() + '\n')
3335
3458
            return
3336
3459
 
 
3460
        if email:
 
3461
            raise errors.BzrCommandError("--email can only be used to display existing "
 
3462
                                         "identity")
 
3463
 
3337
3464
        # display a warning if an email address isn't included in the given name.
3338
3465
        try:
3339
 
            config.extract_email_address(name)
 
3466
            _mod_config.extract_email_address(name)
3340
3467
        except errors.NoEmailInUsername, e:
3341
3468
            warning('"%s" does not seem to contain an email address.  '
3342
3469
                    'This is allowed, but not recommended.', name)
3343
3470
 
3344
3471
        # use global config unless --branch given
3345
3472
        if branch:
3346
 
            c = Branch.open_containing('.')[0].get_config()
 
3473
            if directory is None:
 
3474
                c = Branch.open_containing(u'.')[0].get_config()
 
3475
            else:
 
3476
                c = Branch.open(directory).get_config()
3347
3477
        else:
3348
 
            c = config.GlobalConfig()
 
3478
            c = _mod_config.GlobalConfig()
3349
3479
        c.set_user_option('email', name)
3350
3480
 
3351
3481
 
3418
3548
                'bzr alias --remove expects an alias to remove.')
3419
3549
        # If alias is not found, print something like:
3420
3550
        # unalias: foo: not found
3421
 
        c = config.GlobalConfig()
 
3551
        c = _mod_config.GlobalConfig()
3422
3552
        c.unset_alias(alias_name)
3423
3553
 
3424
3554
    @display_command
3425
3555
    def print_aliases(self):
3426
3556
        """Print out the defined aliases in a similar format to bash."""
3427
 
        aliases = config.GlobalConfig().get_aliases()
 
3557
        aliases = _mod_config.GlobalConfig().get_aliases()
3428
3558
        for key, value in sorted(aliases.iteritems()):
3429
3559
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
3430
3560
 
3440
3570
 
3441
3571
    def set_alias(self, alias_name, alias_command):
3442
3572
        """Save the alias in the global config."""
3443
 
        c = config.GlobalConfig()
 
3573
        c = _mod_config.GlobalConfig()
3444
3574
        c.set_alias(alias_name, alias_command)
3445
3575
 
3446
3576
 
3481
3611
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3482
3612
    into a pdb postmortem session.
3483
3613
 
 
3614
    The --coverage=DIRNAME global option produces a report with covered code
 
3615
    indicated.
 
3616
 
3484
3617
    :Examples:
3485
3618
        Run only tests relating to 'ignore'::
3486
3619
 
3519
3652
                                 'throughout the test suite.',
3520
3653
                            type=get_transport_type),
3521
3654
                     Option('benchmark',
3522
 
                            help='Run the benchmarks rather than selftests.'),
 
3655
                            help='Run the benchmarks rather than selftests.',
 
3656
                            hidden=True),
3523
3657
                     Option('lsprof-timed',
3524
3658
                            help='Generate lsprof output for benchmarked'
3525
3659
                                 ' sections of code.'),
3526
3660
                     Option('lsprof-tests',
3527
3661
                            help='Generate lsprof output for each test.'),
3528
 
                     Option('cache-dir', type=str,
3529
 
                            help='Cache intermediate benchmark output in this '
3530
 
                                 'directory.'),
3531
3662
                     Option('first',
3532
3663
                            help='Run all tests, but run specified tests first.',
3533
3664
                            short_name='f',
3567
3698
 
3568
3699
    def run(self, testspecs_list=None, verbose=False, one=False,
3569
3700
            transport=None, benchmark=None,
3570
 
            lsprof_timed=None, cache_dir=None,
 
3701
            lsprof_timed=None,
3571
3702
            first=False, list_only=False,
3572
3703
            randomize=None, exclude=None, strict=False,
3573
3704
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3574
3705
            parallel=None, lsprof_tests=False):
3575
 
        from bzrlib.tests import selftest
3576
 
        import bzrlib.benchmarks as benchmarks
3577
 
        from bzrlib.benchmarks import tree_creator
3578
 
 
3579
 
        # Make deprecation warnings visible, unless -Werror is set
3580
 
        symbol_versioning.activate_deprecation_warnings(override=False)
3581
 
 
3582
 
        if cache_dir is not None:
3583
 
            tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
 
3706
        from bzrlib import tests
 
3707
 
3584
3708
        if testspecs_list is not None:
3585
3709
            pattern = '|'.join(testspecs_list)
3586
3710
        else:
3594
3718
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3595
3719
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3596
3720
            # stdout, which would corrupt the subunit stream. 
3597
 
            if sys.platform == "win32" and sys.stdout.fileno() >= 0:
 
3721
            # FIXME: This has been fixed in subunit trunk (>0.0.5) so the
 
3722
            # following code can be deleted when it's sufficiently deployed
 
3723
            # -- vila/mgz 20100514
 
3724
            if (sys.platform == "win32"
 
3725
                and getattr(sys.stdout, 'fileno', None) is not None):
3598
3726
                import msvcrt
3599
3727
                msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3600
3728
        if parallel:
3601
3729
            self.additional_selftest_args.setdefault(
3602
3730
                'suite_decorators', []).append(parallel)
3603
3731
        if benchmark:
3604
 
            test_suite_factory = benchmarks.test_suite
3605
 
            # Unless user explicitly asks for quiet, be verbose in benchmarks
3606
 
            verbose = not is_quiet()
3607
 
            # TODO: should possibly lock the history file...
3608
 
            benchfile = open(".perf_history", "at", buffering=1)
3609
 
            self.add_cleanup(benchfile.close)
3610
 
        else:
3611
 
            test_suite_factory = None
3612
 
            benchfile = None
 
3732
            raise errors.BzrCommandError(
 
3733
                "--benchmark is no longer supported from bzr 2.2; "
 
3734
                "use bzr-usertest instead")
 
3735
        test_suite_factory = None
3613
3736
        selftest_kwargs = {"verbose": verbose,
3614
3737
                          "pattern": pattern,
3615
3738
                          "stop_on_failure": one,
3617
3740
                          "test_suite_factory": test_suite_factory,
3618
3741
                          "lsprof_timed": lsprof_timed,
3619
3742
                          "lsprof_tests": lsprof_tests,
3620
 
                          "bench_history": benchfile,
3621
3743
                          "matching_tests_first": first,
3622
3744
                          "list_only": list_only,
3623
3745
                          "random_seed": randomize,
3628
3750
                          "starting_with": starting_with
3629
3751
                          }
3630
3752
        selftest_kwargs.update(self.additional_selftest_args)
3631
 
        result = selftest(**selftest_kwargs)
 
3753
 
 
3754
        # Make deprecation warnings visible, unless -Werror is set
 
3755
        cleanup = symbol_versioning.activate_deprecation_warnings(
 
3756
            override=False)
 
3757
        try:
 
3758
            result = tests.selftest(**selftest_kwargs)
 
3759
        finally:
 
3760
            cleanup()
3632
3761
        return int(not result)
3633
3762
 
3634
3763
 
3691
3820
    with bzr send. If neither is specified, the default is the upstream branch
3692
3821
    or the branch most recently merged using --remember.
3693
3822
 
3694
 
    When merging a branch, by default the tip will be merged. To pick a different
3695
 
    revision, pass --revision. If you specify two values, the first will be used as
3696
 
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
3697
 
    available revisions, like this is commonly referred to as "cherrypicking".
3698
 
 
3699
 
    Revision numbers are always relative to the branch being merged.
3700
 
 
3701
 
    By default, bzr will try to merge in all new work from the other
3702
 
    branch, automatically determining an appropriate base.  If this
3703
 
    fails, you may need to give an explicit base.
 
3823
    When merging from a branch, by default bzr will try to merge in all new
 
3824
    work from the other branch, automatically determining an appropriate base
 
3825
    revision.  If this fails, you may need to give an explicit base.
 
3826
 
 
3827
    To pick a different ending revision, pass "--revision OTHER".  bzr will
 
3828
    try to merge in all new work up to and including revision OTHER.
 
3829
 
 
3830
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
 
3831
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
 
3832
    causes some revisions to be skipped, i.e. if the destination branch does
 
3833
    not already contain revision BASE, such a merge is commonly referred to as
 
3834
    a "cherrypick".
 
3835
 
 
3836
    Revision numbers are always relative to the source branch.
3704
3837
 
3705
3838
    Merge will do its best to combine the changes in two branches, but there
3706
3839
    are some kinds of problems only a human can fix.  When it encounters those,
3730
3863
    you to apply each diff hunk and file change, similar to "shelve".
3731
3864
 
3732
3865
    :Examples:
3733
 
        To merge the latest revision from bzr.dev::
 
3866
        To merge all new revisions from bzr.dev::
3734
3867
 
3735
3868
            bzr merge ../bzr.dev
3736
3869
 
3881
4014
    def _do_preview(self, merger):
3882
4015
        from bzrlib.diff import show_diff_trees
3883
4016
        result_tree = self._get_preview(merger)
 
4017
        path_encoding = osutils.get_diff_header_encoding()
3884
4018
        show_diff_trees(merger.this_tree, result_tree, self.outf,
3885
 
                        old_label='', new_label='')
 
4019
                        old_label='', new_label='',
 
4020
                        path_encoding=path_encoding)
3886
4021
 
3887
4022
    def _do_merge(self, merger, change_reporter, allow_pending, verified):
3888
4023
        merger.change_reporter = change_reporter
3968
4103
        if ((remember or tree.branch.get_submit_branch() is None) and
3969
4104
             user_location is not None):
3970
4105
            tree.branch.set_submit_branch(other_branch.base)
3971
 
        _merge_tags_if_possible(other_branch, tree.branch)
 
4106
        # Merge tags (but don't set them in the master branch yet, the user
 
4107
        # might revert this merge).  Commit will propagate them.
 
4108
        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3972
4109
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3973
4110
            other_revision_id, base_revision_id, other_branch, base_branch)
3974
4111
        if other_path != '':
4075
4212
        from bzrlib.conflicts import restore
4076
4213
        if merge_type is None:
4077
4214
            merge_type = _mod_merge.Merge3Merger
4078
 
        tree, file_list = tree_files(file_list)
 
4215
        tree, file_list = WorkingTree.open_containing_paths(file_list)
4079
4216
        self.add_cleanup(tree.lock_write().unlock)
4080
4217
        parents = tree.get_parent_ids()
4081
4218
        if len(parents) != 2:
4142
4279
    last committed revision is used.
4143
4280
 
4144
4281
    To remove only some changes, without reverting to a prior version, use
4145
 
    merge instead.  For example, "merge . --revision -2..-3" will remove the
4146
 
    changes introduced by -2, without affecting the changes introduced by -1.
4147
 
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
 
4282
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
 
4283
    will remove the changes introduced by the second last commit (-2), without
 
4284
    affecting the changes introduced by the last commit (-1).  To remove
 
4285
    certain changes on a hunk-by-hunk basis, see the shelve command.
4148
4286
 
4149
4287
    By default, any files that have been manually changed will be backed up
4150
4288
    first.  (Files changed only by merge are not backed up.)  Backup files have
4180
4318
    target branches.
4181
4319
    """
4182
4320
 
4183
 
    _see_also = ['cat', 'export']
 
4321
    _see_also = ['cat', 'export', 'merge', 'shelve']
4184
4322
    takes_options = [
4185
4323
        'revision',
4186
4324
        Option('no-backup', "Do not save backups of reverted files."),
4191
4329
 
4192
4330
    def run(self, revision=None, no_backup=False, file_list=None,
4193
4331
            forget_merges=None):
4194
 
        tree, file_list = tree_files(file_list)
 
4332
        tree, file_list = WorkingTree.open_containing_paths(file_list)
4195
4333
        self.add_cleanup(tree.lock_tree_write().unlock)
4196
4334
        if forget_merges:
4197
4335
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4287
4425
    _see_also = ['merge', 'pull']
4288
4426
    takes_args = ['other_branch?']
4289
4427
    takes_options = [
 
4428
        'directory',
4290
4429
        Option('reverse', 'Reverse the order of revisions.'),
4291
4430
        Option('mine-only',
4292
4431
               'Display changes in the local branch only.'),
4314
4453
            theirs_only=False,
4315
4454
            log_format=None, long=False, short=False, line=False,
4316
4455
            show_ids=False, verbose=False, this=False, other=False,
4317
 
            include_merges=False, revision=None, my_revision=None):
 
4456
            include_merges=False, revision=None, my_revision=None,
 
4457
            directory=u'.'):
4318
4458
        from bzrlib.missing import find_unmerged, iter_log_revisions
4319
4459
        def message(s):
4320
4460
            if not is_quiet():
4333
4473
        elif theirs_only:
4334
4474
            restrict = 'remote'
4335
4475
 
4336
 
        local_branch = Branch.open_containing(u".")[0]
 
4476
        local_branch = Branch.open_containing(directory)[0]
4337
4477
        self.add_cleanup(local_branch.lock_read().unlock)
4338
4478
 
4339
4479
        parent = local_branch.get_parent()
4477
4617
 
4478
4618
    @display_command
4479
4619
    def run(self, verbose=False):
4480
 
        import bzrlib.plugin
4481
 
        from inspect import getdoc
4482
 
        result = []
4483
 
        for name, plugin in bzrlib.plugin.plugins().items():
4484
 
            version = plugin.__version__
4485
 
            if version == 'unknown':
4486
 
                version = ''
4487
 
            name_ver = '%s %s' % (name, version)
4488
 
            d = getdoc(plugin.module)
4489
 
            if d:
4490
 
                doc = d.split('\n')[0]
4491
 
            else:
4492
 
                doc = '(no description)'
4493
 
            result.append((name_ver, doc, plugin.path()))
4494
 
        for name_ver, doc, path in sorted(result):
4495
 
            self.outf.write("%s\n" % name_ver)
4496
 
            self.outf.write("   %s\n" % doc)
4497
 
            if verbose:
4498
 
                self.outf.write("   %s\n" % path)
4499
 
            self.outf.write("\n")
 
4620
        from bzrlib import plugin
 
4621
        self.outf.writelines(
 
4622
            plugin.describe_plugins(show_paths=verbose))
4500
4623
 
4501
4624
 
4502
4625
class cmd_testament(Command):
4564
4687
            self.add_cleanup(branch.lock_read().unlock)
4565
4688
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4566
4689
        self.add_cleanup(tree.lock_read().unlock)
4567
 
        if wt is not None:
 
4690
        if wt is not None and revision is None:
4568
4691
            file_id = wt.path2id(relpath)
4569
4692
        else:
4570
4693
            file_id = tree.path2id(relpath)
4571
4694
        if file_id is None:
4572
4695
            raise errors.NotVersionedError(filename)
4573
 
        file_version = tree.inventory[file_id].revision
4574
4696
        if wt is not None and revision is None:
4575
4697
            # If there is a tree and we're not annotating historical
4576
4698
            # versions, annotate the working tree's content.
4577
4699
            annotate_file_tree(wt, file_id, self.outf, long, all,
4578
4700
                show_ids=show_ids)
4579
4701
        else:
 
4702
            file_version = tree.inventory[file_id].revision
4580
4703
            annotate_file(branch, file_version, file_id, long, all, self.outf,
4581
4704
                          show_ids=show_ids)
4582
4705
 
4798
4921
            self.outf.write('The above revision(s) will be removed.\n')
4799
4922
 
4800
4923
        if not force:
4801
 
            if not ui.ui_factory.get_boolean('Are you sure'):
4802
 
                self.outf.write('Canceled')
 
4924
            if not ui.ui_factory.confirm_action(
 
4925
                    'Uncommit these revisions',
 
4926
                    'bzrlib.builtins.uncommit',
 
4927
                    {}):
 
4928
                self.outf.write('Canceled\n')
4803
4929
                return 0
4804
4930
 
4805
4931
        mutter('Uncommitting from {%s} to {%s}',
4811
4937
 
4812
4938
 
4813
4939
class cmd_break_lock(Command):
4814
 
    __doc__ = """Break a dead lock on a repository, branch or working directory.
 
4940
    __doc__ = """Break a dead lock.
 
4941
 
 
4942
    This command breaks a lock on a repository, branch, working directory or
 
4943
    config file.
4815
4944
 
4816
4945
    CAUTION: Locks should only be broken when you are sure that the process
4817
4946
    holding the lock has been stopped.
4822
4951
    :Examples:
4823
4952
        bzr break-lock
4824
4953
        bzr break-lock bzr+ssh://example.com/bzr/foo
 
4954
        bzr break-lock --conf ~/.bazaar
4825
4955
    """
 
4956
 
4826
4957
    takes_args = ['location?']
 
4958
    takes_options = [
 
4959
        Option('config',
 
4960
               help='LOCATION is the directory where the config lock is.'),
 
4961
        Option('force',
 
4962
            help='Do not ask for confirmation before breaking the lock.'),
 
4963
        ]
4827
4964
 
4828
 
    def run(self, location=None, show=False):
 
4965
    def run(self, location=None, config=False, force=False):
4829
4966
        if location is None:
4830
4967
            location = u'.'
4831
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
4832
 
        try:
4833
 
            control.break_lock()
4834
 
        except NotImplementedError:
4835
 
            pass
 
4968
        if force:
 
4969
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
 
4970
                None,
 
4971
                {'bzrlib.lockdir.break': True})
 
4972
        if config:
 
4973
            conf = _mod_config.LockableConfig(file_name=location)
 
4974
            conf.break_lock()
 
4975
        else:
 
4976
            control, relpath = bzrdir.BzrDir.open_containing(location)
 
4977
            try:
 
4978
                control.break_lock()
 
4979
            except NotImplementedError:
 
4980
                pass
4836
4981
 
4837
4982
 
4838
4983
class cmd_wait_until_signalled(Command):
4901
5046
 
4902
5047
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
4903
5048
            protocol=None):
4904
 
        from bzrlib.transport import get_transport, transport_server_registry
 
5049
        from bzrlib import transport
4905
5050
        if directory is None:
4906
5051
            directory = os.getcwd()
4907
5052
        if protocol is None:
4908
 
            protocol = transport_server_registry.get()
 
5053
            protocol = transport.transport_server_registry.get()
4909
5054
        host, port = self.get_host_and_port(port)
4910
5055
        url = urlutils.local_path_to_url(directory)
4911
5056
        if not allow_writes:
4912
5057
            url = 'readonly+' + url
4913
 
        transport = get_transport(url)
4914
 
        protocol(transport, host, port, inet)
 
5058
        t = transport.get_transport(url)
 
5059
        protocol(t, host, port, inet)
4915
5060
 
4916
5061
 
4917
5062
class cmd_join(Command):
4923
5068
    not part of it.  (Such trees can be produced by "bzr split", but also by
4924
5069
    running "bzr branch" with the target inside a tree.)
4925
5070
 
4926
 
    The result is a combined tree, with the subtree no longer an independant
 
5071
    The result is a combined tree, with the subtree no longer an independent
4927
5072
    part.  This is marked as a merge of the subtree into the containing tree,
4928
5073
    and all history is preserved.
4929
5074
    """
5010
5155
    _see_also = ['send']
5011
5156
 
5012
5157
    takes_options = [
 
5158
        'directory',
5013
5159
        RegistryOption.from_kwargs('patch-type',
5014
5160
            'The type of patch to include in the directive.',
5015
5161
            title='Patch type',
5028
5174
    encoding_type = 'exact'
5029
5175
 
5030
5176
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5031
 
            sign=False, revision=None, mail_to=None, message=None):
 
5177
            sign=False, revision=None, mail_to=None, message=None,
 
5178
            directory=u'.'):
5032
5179
        from bzrlib.revision import ensure_null, NULL_REVISION
5033
5180
        include_patch, include_bundle = {
5034
5181
            'plain': (False, False),
5035
5182
            'diff': (True, False),
5036
5183
            'bundle': (True, True),
5037
5184
            }[patch_type]
5038
 
        branch = Branch.open('.')
 
5185
        branch = Branch.open(directory)
5039
5186
        stored_submit_branch = branch.get_submit_branch()
5040
5187
        if submit_branch is None:
5041
5188
            submit_branch = stored_submit_branch
5126
5273
    given, in which case it is sent to a file.
5127
5274
 
5128
5275
    Mail is sent using your preferred mail program.  This should be transparent
5129
 
    on Windows (it uses MAPI).  On Linux, it requires the xdg-email utility.
 
5276
    on Windows (it uses MAPI).  On Unix, it requires the xdg-email utility.
5130
5277
    If the preferred client can't be found (or used), your editor will be used.
5131
5278
 
5132
5279
    To use a specific mail program, set the mail_client configuration option.
5323
5470
            if tag_name is None:
5324
5471
                raise errors.BzrCommandError("No tag specified to delete.")
5325
5472
            branch.tags.delete_tag(tag_name)
5326
 
            self.outf.write('Deleted tag %s.\n' % tag_name)
 
5473
            note('Deleted tag %s.' % tag_name)
5327
5474
        else:
5328
5475
            if revision:
5329
5476
                if len(revision) != 1:
5341
5488
            if (not force) and branch.tags.has_tag(tag_name):
5342
5489
                raise errors.TagAlreadyExists(tag_name)
5343
5490
            branch.tags.set_tag(tag_name, revision_id)
5344
 
            self.outf.write('Created tag %s.\n' % tag_name)
 
5491
            note('Created tag %s.' % tag_name)
5345
5492
 
5346
5493
 
5347
5494
class cmd_tags(Command):
5354
5501
    takes_options = [
5355
5502
        custom_help('directory',
5356
5503
            help='Branch whose tags should be displayed.'),
5357
 
        RegistryOption.from_kwargs('sort',
 
5504
        RegistryOption('sort',
5358
5505
            'Sort tags by different criteria.', title='Sorting',
5359
 
            alpha='Sort tags lexicographically (default).',
5360
 
            time='Sort tags chronologically.',
 
5506
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5361
5507
            ),
5362
5508
        'show-ids',
5363
5509
        'revision',
5364
5510
    ]
5365
5511
 
5366
5512
    @display_command
5367
 
    def run(self,
5368
 
            directory='.',
5369
 
            sort='alpha',
5370
 
            show_ids=False,
5371
 
            revision=None,
5372
 
            ):
 
5513
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
 
5514
        from bzrlib.tag import tag_sort_methods
5373
5515
        branch, relpath = Branch.open_containing(directory)
5374
5516
 
5375
5517
        tags = branch.tags.get_tag_dict().items()
5384
5526
            # only show revisions between revid1 and revid2 (inclusive)
5385
5527
            tags = [(tag, revid) for tag, revid in tags if
5386
5528
                graph.is_between(revid, revid1, revid2)]
5387
 
        if sort == 'alpha':
5388
 
            tags.sort()
5389
 
        elif sort == 'time':
5390
 
            timestamps = {}
5391
 
            for tag, revid in tags:
5392
 
                try:
5393
 
                    revobj = branch.repository.get_revision(revid)
5394
 
                except errors.NoSuchRevision:
5395
 
                    timestamp = sys.maxint # place them at the end
5396
 
                else:
5397
 
                    timestamp = revobj.timestamp
5398
 
                timestamps[revid] = timestamp
5399
 
            tags.sort(key=lambda x: timestamps[x[1]])
 
5529
        if sort is None:
 
5530
            sort = tag_sort_methods.get()
 
5531
        sort(branch, tags)
5400
5532
        if not show_ids:
5401
5533
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5402
5534
            for index, (tag, revid) in enumerate(tags):
5404
5536
                    revno = branch.revision_id_to_dotted_revno(revid)
5405
5537
                    if isinstance(revno, tuple):
5406
5538
                        revno = '.'.join(map(str, revno))
5407
 
                except errors.NoSuchRevision:
 
5539
                except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
5408
5540
                    # Bad tag data/merges can lead to tagged revisions
5409
5541
                    # which are not in this branch. Fail gracefully ...
5410
5542
                    revno = '?'
5529
5661
    """
5530
5662
 
5531
5663
    takes_args = ['to_location?']
5532
 
    takes_options = [Option('force',
 
5664
    takes_options = ['directory',
 
5665
                     Option('force',
5533
5666
                        help='Switch even if local commits will be lost.'),
5534
5667
                     'revision',
5535
5668
                     Option('create-branch', short_name='b',
5538
5671
                    ]
5539
5672
 
5540
5673
    def run(self, to_location=None, force=False, create_branch=False,
5541
 
            revision=None):
 
5674
            revision=None, directory=u'.'):
5542
5675
        from bzrlib import switch
5543
 
        tree_location = '.'
 
5676
        tree_location = directory
5544
5677
        revision = _get_one_revision('switch', revision)
5545
5678
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5546
5679
        if to_location is None:
5547
5680
            if revision is None:
5548
5681
                raise errors.BzrCommandError('You must supply either a'
5549
5682
                                             ' revision or a location')
5550
 
            to_location = '.'
 
5683
            to_location = tree_location
5551
5684
        try:
5552
5685
            branch = control_dir.open_branch()
5553
5686
            had_explicit_nick = branch.get_config().has_explicit_nickname()
5688
5821
            name=None,
5689
5822
            switch=None,
5690
5823
            ):
5691
 
        tree, file_list = tree_files(file_list, apply_view=False)
 
5824
        tree, file_list = WorkingTree.open_containing_paths(file_list,
 
5825
            apply_view=False)
5692
5826
        current_view, view_dict = tree.views.get_view_info()
5693
5827
        if name is None:
5694
5828
            name = current_view
5798
5932
            location = "."
5799
5933
        branch = Branch.open_containing(location)[0]
5800
5934
        branch.bzrdir.destroy_branch()
5801
 
        
 
5935
 
5802
5936
 
5803
5937
class cmd_shelve(Command):
5804
5938
    __doc__ = """Temporarily set aside some changes from the current tree.
5823
5957
 
5824
5958
    You can put multiple items on the shelf, and by default, 'unshelve' will
5825
5959
    restore the most recently shelved changes.
 
5960
 
 
5961
    For complicated changes, it is possible to edit the changes in a separate
 
5962
    editor program to decide what the file remaining in the working copy
 
5963
    should look like.  To do this, add the configuration option
 
5964
 
 
5965
        change_editor = PROGRAM @new_path @old_path
 
5966
 
 
5967
    where @new_path is replaced with the path of the new version of the 
 
5968
    file and @old_path is replaced with the path of the old version of 
 
5969
    the file.  The PROGRAM should save the new file with the desired 
 
5970
    contents of the file in the working tree.
 
5971
        
5826
5972
    """
5827
5973
 
5828
5974
    takes_args = ['file*']
5829
5975
 
5830
5976
    takes_options = [
 
5977
        'directory',
5831
5978
        'revision',
5832
5979
        Option('all', help='Shelve all changes.'),
5833
5980
        'message',
5839
5986
        Option('destroy',
5840
5987
               help='Destroy removed changes instead of shelving them.'),
5841
5988
    ]
5842
 
    _see_also = ['unshelve']
 
5989
    _see_also = ['unshelve', 'configuration']
5843
5990
 
5844
5991
    def run(self, revision=None, all=False, file_list=None, message=None,
5845
 
            writer=None, list=False, destroy=False):
 
5992
            writer=None, list=False, destroy=False, directory=None):
5846
5993
        if list:
5847
 
            return self.run_for_list()
 
5994
            return self.run_for_list(directory=directory)
5848
5995
        from bzrlib.shelf_ui import Shelver
5849
5996
        if writer is None:
5850
5997
            writer = bzrlib.option.diff_writer_registry.get()
5851
5998
        try:
5852
5999
            shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5853
 
                file_list, message, destroy=destroy)
 
6000
                file_list, message, destroy=destroy, directory=directory)
5854
6001
            try:
5855
6002
                shelver.run()
5856
6003
            finally:
5858
6005
        except errors.UserAbort:
5859
6006
            return 0
5860
6007
 
5861
 
    def run_for_list(self):
5862
 
        tree = WorkingTree.open_containing('.')[0]
 
6008
    def run_for_list(self, directory=None):
 
6009
        if directory is None:
 
6010
            directory = u'.'
 
6011
        tree = WorkingTree.open_containing(directory)[0]
5863
6012
        self.add_cleanup(tree.lock_read().unlock)
5864
6013
        manager = tree.get_shelf_manager()
5865
6014
        shelves = manager.active_shelves()
5884
6033
 
5885
6034
    takes_args = ['shelf_id?']
5886
6035
    takes_options = [
 
6036
        'directory',
5887
6037
        RegistryOption.from_kwargs(
5888
6038
            'action', help="The action to perform.",
5889
6039
            enum_switch=False, value_switches=True,
5897
6047
    ]
5898
6048
    _see_also = ['shelve']
5899
6049
 
5900
 
    def run(self, shelf_id=None, action='apply'):
 
6050
    def run(self, shelf_id=None, action='apply', directory=u'.'):
5901
6051
        from bzrlib.shelf_ui import Unshelver
5902
 
        unshelver = Unshelver.from_args(shelf_id, action)
 
6052
        unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5903
6053
        try:
5904
6054
            unshelver.run()
5905
6055
        finally:
5923
6073
    """
5924
6074
    takes_options = ['directory',
5925
6075
                     Option('ignored', help='Delete all ignored files.'),
5926
 
                     Option('detritus', help='Delete conflict files, merge'
 
6076
                     Option('detritus', help='Delete conflict files, merge and revert'
5927
6077
                            ' backups, and failed selftest dirs.'),
5928
6078
                     Option('unknown',
5929
6079
                            help='Delete files unknown to bzr (default).'),
5993
6143
    # be only called once.
5994
6144
    for (name, aliases, module_name) in [
5995
6145
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
 
6146
        ('cmd_config', [], 'bzrlib.config'),
5996
6147
        ('cmd_dpush', [], 'bzrlib.foreign'),
5997
6148
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
5998
6149
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
5999
6150
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6000
6151
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
 
6152
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6001
6153
        ]:
6002
6154
        builtin_command_registry.register_lazy(name, aliases, module_name)