/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: mbp at sourcefrog
  • Date: 2011-04-11 01:23:58 UTC
  • mfrom: (5777 +trunk)
  • mto: This revision was merged to the branch mainline in revision 5802.
  • Revision ID: mbp@sourcefrog.net-20110411012358-gl07rdtxydlq7fh1
merge news

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):
1171
1205
 
1172
1206
    To retrieve the branch as of a particular revision, supply the --revision
1173
1207
    parameter, as in "branch foo/bar -r 5".
 
1208
 
 
1209
    The synonyms 'clone' and 'get' for this command are deprecated.
1174
1210
    """
1175
1211
 
1176
1212
    _see_also = ['checkout']
1177
1213
    takes_args = ['from_location', 'to_location?']
1178
 
    takes_options = ['revision', Option('hardlink',
1179
 
        help='Hard-link working tree files where possible.'),
 
1214
    takes_options = ['revision',
 
1215
        Option('hardlink', help='Hard-link working tree files where possible.'),
 
1216
        Option('files-from', type=str,
 
1217
               help="Get file contents from this tree."),
1180
1218
        Option('no-tree',
1181
1219
            help="Create a branch without a working-tree."),
1182
1220
        Option('switch',
1200
1238
 
1201
1239
    def run(self, from_location, to_location=None, revision=None,
1202
1240
            hardlink=False, stacked=False, standalone=False, no_tree=False,
1203
 
            use_existing_dir=False, switch=False, bind=False):
 
1241
            use_existing_dir=False, switch=False, bind=False,
 
1242
            files_from=None):
1204
1243
        from bzrlib import switch as _mod_switch
1205
1244
        from bzrlib.tag import _merge_tags_if_possible
 
1245
        if self.invoked_as in ['get', 'clone']:
 
1246
            ui.ui_factory.show_user_warning(
 
1247
                'deprecated_command',
 
1248
                deprecated_name=self.invoked_as,
 
1249
                recommended_name='branch',
 
1250
                deprecated_in_version='2.4')
1206
1251
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1207
1252
            from_location)
 
1253
        if not (hardlink or files_from):
 
1254
            # accelerator_tree is usually slower because you have to read N
 
1255
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1256
            # explicitly request it
 
1257
            accelerator_tree = None
 
1258
        if files_from is not None and files_from != from_location:
 
1259
            accelerator_tree = WorkingTree.open(files_from)
1208
1260
        revision = _get_one_revision('branch', revision)
1209
1261
        self.add_cleanup(br_from.lock_read().unlock)
1210
1262
        if revision is not None:
1317
1369
            to_location = branch_location
1318
1370
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1319
1371
            branch_location)
 
1372
        if not (hardlink or files_from):
 
1373
            # accelerator_tree is usually slower because you have to read N
 
1374
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1375
            # explicitly request it
 
1376
            accelerator_tree = None
1320
1377
        revision = _get_one_revision('checkout', revision)
1321
 
        if files_from is not None:
 
1378
        if files_from is not None and files_from != branch_location:
1322
1379
            accelerator_tree = WorkingTree.open(files_from)
1323
1380
        if revision is not None:
1324
1381
            revision_id = revision.as_revision_id(source)
1336
1393
            except errors.NoWorkingTree:
1337
1394
                source.bzrdir.create_workingtree(revision_id)
1338
1395
                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
1396
        source.create_checkout(to_location, revision_id, lightweight,
1345
1397
                               accelerator_tree, hardlink)
1346
1398
 
1385
1437
    If you want to discard your local changes, you can just do a
1386
1438
    'bzr revert' instead of 'bzr commit' after the update.
1387
1439
 
 
1440
    If you want to restore a file that has been removed locally, use
 
1441
    'bzr revert' instead of 'bzr update'.
 
1442
 
1388
1443
    If the tree's branch is bound to a master branch, it will also update
1389
1444
    the branch from the master.
1390
1445
    """
1391
1446
 
1392
1447
    _see_also = ['pull', 'working-trees', 'status-flags']
1393
1448
    takes_args = ['dir?']
1394
 
    takes_options = ['revision']
 
1449
    takes_options = ['revision',
 
1450
                     Option('show-base',
 
1451
                            help="Show base revision text in conflicts."),
 
1452
                     ]
1395
1453
    aliases = ['up']
1396
1454
 
1397
 
    def run(self, dir='.', revision=None):
 
1455
    def run(self, dir='.', revision=None, show_base=None):
1398
1456
        if revision is not None and len(revision) != 1:
1399
1457
            raise errors.BzrCommandError(
1400
1458
                        "bzr update --revision takes exactly one revision")
1440
1498
                change_reporter,
1441
1499
                possible_transports=possible_transports,
1442
1500
                revision=revision_id,
1443
 
                old_tip=old_tip)
 
1501
                old_tip=old_tip,
 
1502
                show_base=show_base)
1444
1503
        except errors.NoSuchRevision, e:
1445
1504
            raise errors.BzrCommandError(
1446
1505
                                  "branch has no revision %s\n"
1508
1567
class cmd_remove(Command):
1509
1568
    __doc__ = """Remove files or directories.
1510
1569
 
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.
 
1570
    This makes Bazaar stop tracking changes to the specified files. Bazaar will
 
1571
    delete them if they can easily be recovered using revert otherwise they
 
1572
    will be backed up (adding an extention of the form .~#~). If no options or
 
1573
    parameters are given Bazaar will scan for files that are being tracked by
 
1574
    Bazaar but missing in your tree and stop tracking them for you.
1515
1575
    """
1516
1576
    takes_args = ['file*']
1517
1577
    takes_options = ['verbose',
1519
1579
        RegistryOption.from_kwargs('file-deletion-strategy',
1520
1580
            'The file deletion mode to be used.',
1521
1581
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1522
 
            safe='Only delete files if they can be'
1523
 
                 ' safely recovered (default).',
 
1582
            safe='Backup changed files (default).',
1524
1583
            keep='Delete from bzr but leave the working copy.',
 
1584
            no_backup='Don\'t backup changed files.',
1525
1585
            force='Delete all the specified files, even if they can not be '
1526
 
                'recovered and even if they are non-empty directories.')]
 
1586
                'recovered and even if they are non-empty directories. '
 
1587
                '(deprecated, use no-backup)')]
1527
1588
    aliases = ['rm', 'del']
1528
1589
    encoding_type = 'replace'
1529
1590
 
1530
1591
    def run(self, file_list, verbose=False, new=False,
1531
1592
        file_deletion_strategy='safe'):
1532
 
        tree, file_list = tree_files(file_list)
 
1593
        if file_deletion_strategy == 'force':
 
1594
            note("(The --force option is deprecated, rather use --no-backup "
 
1595
                "in future.)")
 
1596
            file_deletion_strategy = 'no-backup'
 
1597
 
 
1598
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1533
1599
 
1534
1600
        if file_list is not None:
1535
1601
            file_list = [f for f in file_list]
1555
1621
            file_deletion_strategy = 'keep'
1556
1622
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1557
1623
            keep_files=file_deletion_strategy=='keep',
1558
 
            force=file_deletion_strategy=='force')
 
1624
            force=(file_deletion_strategy=='no-backup'))
1559
1625
 
1560
1626
 
1561
1627
class cmd_file_id(Command):
1623
1689
 
1624
1690
    _see_also = ['check']
1625
1691
    takes_args = ['branch?']
 
1692
    takes_options = [
 
1693
        Option('canonicalize-chks',
 
1694
               help='Make sure CHKs are in canonical form (repairs '
 
1695
                    'bug 522637).',
 
1696
               hidden=True),
 
1697
        ]
1626
1698
 
1627
 
    def run(self, branch="."):
 
1699
    def run(self, branch=".", canonicalize_chks=False):
1628
1700
        from bzrlib.reconcile import reconcile
1629
1701
        dir = bzrdir.BzrDir.open(branch)
1630
 
        reconcile(dir)
 
1702
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1631
1703
 
1632
1704
 
1633
1705
class cmd_revision_history(Command):
1710
1782
                ),
1711
1783
         Option('append-revisions-only',
1712
1784
                help='Never change revnos or the existing log.'
1713
 
                '  Append revisions to it only.')
 
1785
                '  Append revisions to it only.'),
 
1786
         Option('no-tree',
 
1787
                'Create a branch without a working tree.')
1714
1788
         ]
1715
1789
    def run(self, location=None, format=None, append_revisions_only=False,
1716
 
            create_prefix=False):
 
1790
            create_prefix=False, no_tree=False):
1717
1791
        if format is None:
1718
1792
            format = bzrdir.format_registry.make_bzrdir('default')
1719
1793
        if location is None:
1742
1816
        except errors.NotBranchError:
1743
1817
            # really a NotBzrDir error...
1744
1818
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
1819
            if no_tree:
 
1820
                force_new_tree = False
 
1821
            else:
 
1822
                force_new_tree = None
1745
1823
            branch = create_branch(to_transport.base, format=format,
1746
 
                                   possible_transports=[to_transport])
 
1824
                                   possible_transports=[to_transport],
 
1825
                                   force_new_tree=force_new_tree)
1747
1826
            a_bzrdir = branch.bzrdir
1748
1827
        else:
1749
1828
            from bzrlib.transport.local import LocalTransport
1753
1832
                        raise errors.BranchExistsWithoutWorkingTree(location)
1754
1833
                raise errors.AlreadyBranchError(location)
1755
1834
            branch = a_bzrdir.create_branch()
1756
 
            a_bzrdir.create_workingtree()
 
1835
            if not no_tree:
 
1836
                a_bzrdir.create_workingtree()
1757
1837
        if append_revisions_only:
1758
1838
            try:
1759
1839
                branch.set_append_revisions_only(True)
1853
1933
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1854
1934
    produces patches suitable for "patch -p1".
1855
1935
 
 
1936
    Note that when using the -r argument with a range of revisions, the
 
1937
    differences are computed between the two specified revisions.  That
 
1938
    is, the command does not show the changes introduced by the first 
 
1939
    revision in the range.  This differs from the interpretation of 
 
1940
    revision ranges used by "bzr log" which includes the first revision
 
1941
    in the range.
 
1942
 
1856
1943
    :Exit values:
1857
1944
        1 - changed
1858
1945
        2 - unrepresentable changes
1876
1963
 
1877
1964
            bzr diff -r1..3 xxx
1878
1965
 
1879
 
        To see the changes introduced in revision X::
 
1966
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1967
 
 
1968
            bzr diff -c2
 
1969
 
 
1970
        To see the changes introduced by revision X::
1880
1971
        
1881
1972
            bzr diff -cX
1882
1973
 
1886
1977
 
1887
1978
            bzr diff -r<chosen_parent>..X
1888
1979
 
1889
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
1980
        The changes between the current revision and the previous revision
 
1981
        (equivalent to -c-1 and -r-2..-1)
1890
1982
 
1891
 
            bzr diff -c2
 
1983
            bzr diff -r-2..
1892
1984
 
1893
1985
        Show just the differences for file NEWS::
1894
1986
 
1909
2001
        Same as 'bzr diff' but prefix paths with old/ and new/::
1910
2002
 
1911
2003
            bzr diff --prefix old/:new/
 
2004
            
 
2005
        Show the differences using a custom diff program with options::
 
2006
        
 
2007
            bzr diff --using /usr/bin/diff --diff-options -wu
1912
2008
    """
1913
2009
    _see_also = ['status']
1914
2010
    takes_args = ['file*']
1934
2030
            type=unicode,
1935
2031
            ),
1936
2032
        RegistryOption('format',
 
2033
            short_name='F',
1937
2034
            help='Diff format to use.',
1938
2035
            lazy_registry=('bzrlib.diff', 'format_registry'),
1939
 
            value_switches=False, title='Diff format'),
 
2036
            title='Diff format'),
1940
2037
        ]
1941
2038
    aliases = ['di', 'dif']
1942
2039
    encoding_type = 'exact'
1973
2070
         old_branch, new_branch,
1974
2071
         specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1975
2072
            file_list, revision, old, new, self.add_cleanup, apply_view=True)
 
2073
        # GNU diff on Windows uses ANSI encoding for filenames
 
2074
        path_encoding = osutils.get_diff_header_encoding()
1976
2075
        return show_diff_trees(old_tree, new_tree, sys.stdout,
1977
2076
                               specific_files=specific_files,
1978
2077
                               external_diff_options=diff_options,
1979
2078
                               old_label=old_label, new_label=new_label,
1980
 
                               extra_trees=extra_trees, using=using,
 
2079
                               extra_trees=extra_trees,
 
2080
                               path_encoding=path_encoding,
 
2081
                               using=using,
1981
2082
                               format_cls=format)
1982
2083
 
1983
2084
 
2019
2120
    @display_command
2020
2121
    def run(self, null=False, directory=u'.'):
2021
2122
        tree = WorkingTree.open_containing(directory)[0]
 
2123
        self.add_cleanup(tree.lock_read().unlock)
2022
2124
        td = tree.changes_from(tree.basis_tree())
 
2125
        self.cleanup_now()
2023
2126
        for path, id, kind, text_modified, meta_modified in td.modified:
2024
2127
            if null:
2025
2128
                self.outf.write(path + '\0')
2655
2758
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2656
2759
    precedence over the '!' exception patterns.
2657
2760
 
2658
 
    Note: ignore patterns containing shell wildcards must be quoted from
2659
 
    the shell on Unix.
 
2761
    :Notes: 
 
2762
        
 
2763
    * Ignore patterns containing shell wildcards must be quoted from
 
2764
      the shell on Unix.
 
2765
 
 
2766
    * Ignore patterns starting with "#" act as comments in the ignore file.
 
2767
      To ignore patterns that begin with that character, use the "RE:" prefix.
2660
2768
 
2661
2769
    :Examples:
2662
2770
        Ignore the top level Makefile::
2671
2779
 
2672
2780
            bzr ignore "!special.class"
2673
2781
 
 
2782
        Ignore files whose name begins with the "#" character::
 
2783
 
 
2784
            bzr ignore "RE:^#"
 
2785
 
2674
2786
        Ignore .o files under the lib directory::
2675
2787
 
2676
2788
            bzr ignore "lib/**/*.o"
2684
2796
            bzr ignore "RE:(?!debian/).*"
2685
2797
        
2686
2798
        Ignore everything except the "local" toplevel directory,
2687
 
        but always ignore "*~" autosave files, even under local/::
 
2799
        but always ignore autosave files ending in ~, even under local/::
2688
2800
        
2689
2801
            bzr ignore "*"
2690
2802
            bzr ignore "!./local"
2711
2823
                "NAME_PATTERN or --default-rules.")
2712
2824
        name_pattern_list = [globbing.normalize_pattern(p)
2713
2825
                             for p in name_pattern_list]
 
2826
        bad_patterns = ''
 
2827
        for p in name_pattern_list:
 
2828
            if not globbing.Globster.is_pattern_valid(p):
 
2829
                bad_patterns += ('\n  %s' % p)
 
2830
        if bad_patterns:
 
2831
            msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
 
2832
            ui.ui_factory.show_error(msg)
 
2833
            raise errors.InvalidPattern('')
2714
2834
        for name_pattern in name_pattern_list:
2715
2835
            if (name_pattern[0] == '/' or
2716
2836
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2720
2840
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2721
2841
        ignored = globbing.Globster(name_pattern_list)
2722
2842
        matches = []
2723
 
        tree.lock_read()
 
2843
        self.add_cleanup(tree.lock_read().unlock)
2724
2844
        for entry in tree.list_files():
2725
2845
            id = entry[3]
2726
2846
            if id is not None:
2727
2847
                filename = entry[0]
2728
2848
                if ignored.match(filename):
2729
2849
                    matches.append(filename)
2730
 
        tree.unlock()
2731
2850
        if len(matches) > 0:
2732
2851
            self.outf.write("Warning: the following files are version controlled and"
2733
2852
                  " match your ignore pattern:\n%s"
2811
2930
         zip                          .zip
2812
2931
      =================       =========================
2813
2932
    """
 
2933
    encoding = 'exact'
2814
2934
    takes_args = ['dest', 'branch_or_subdir?']
2815
2935
    takes_options = ['directory',
2816
2936
        Option('format',
2994
3114
      to trigger updates to external systems like bug trackers. The --fixes
2995
3115
      option can be used to record the association between a revision and
2996
3116
      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
3117
    """
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
3118
 
3024
3119
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3025
3120
    takes_args = ['selected*']
3058
3153
                    help='When no message is supplied, show the diff along'
3059
3154
                    ' with the status summary in the message editor.'),
3060
3155
             ]
3061
 
    aliases = ['ci', 'checkin']
 
3156
    aliases = ['ci']
3062
3157
 
3063
3158
    def _iter_bug_fix_urls(self, fixes, branch):
3064
3159
        # Configure the properties for bug fixing attributes.
3101
3196
                raise errors.BzrCommandError(
3102
3197
                    "Could not parse --commit-time: " + str(e))
3103
3198
 
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
3199
        properties = {}
3111
3200
 
3112
 
        tree, selected_list = tree_files(selected_list)
 
3201
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3113
3202
        if selected_list == ['']:
3114
3203
            # workaround - commit of root of tree should be exactly the same
3115
3204
            # as just default commit in that tree, and succeed even though
3150
3239
        def get_message(commit_obj):
3151
3240
            """Callback to get commit message"""
3152
3241
            if file:
3153
 
                my_message = codecs.open(
3154
 
                    file, 'rt', osutils.get_user_encoding()).read()
 
3242
                f = open(file)
 
3243
                try:
 
3244
                    my_message = f.read().decode(osutils.get_user_encoding())
 
3245
                finally:
 
3246
                    f.close()
3155
3247
            elif message is not None:
3156
3248
                my_message = message
3157
3249
            else:
3186
3278
                        reporter=None, verbose=verbose, revprops=properties,
3187
3279
                        authors=author, timestamp=commit_stamp,
3188
3280
                        timezone=offset,
3189
 
                        exclude=safe_relpath_files(tree, exclude))
 
3281
                        exclude=tree.safe_relpath_files(exclude))
3190
3282
        except PointlessCommit:
3191
3283
            raise errors.BzrCommandError("No changes to commit."
3192
 
                              " Use --unchanged to commit anyhow.")
 
3284
                " Please 'bzr add' the files you want to commit, or use"
 
3285
                " --unchanged to force an empty commit.")
3193
3286
        except ConflictsInTree:
3194
3287
            raise errors.BzrCommandError('Conflicts detected in working '
3195
3288
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
3276
3369
 
3277
3370
 
3278
3371
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.
 
3372
    __doc__ = """Upgrade a repository, branch or working tree to a newer format.
 
3373
 
 
3374
    When the default format has changed after a major new release of
 
3375
    Bazaar, you may be informed during certain operations that you
 
3376
    should upgrade. Upgrading to a newer format may improve performance
 
3377
    or make new features available. It may however limit interoperability
 
3378
    with older repositories or with older versions of Bazaar.
 
3379
 
 
3380
    If you wish to upgrade to a particular format rather than the
 
3381
    current default, that can be specified using the --format option.
 
3382
    As a consequence, you can use the upgrade command this way to
 
3383
    "downgrade" to an earlier format, though some conversions are
 
3384
    a one way process (e.g. changing from the 1.x default to the
 
3385
    2.x default) so downgrading is not always possible.
 
3386
 
 
3387
    A backup.bzr.~#~ directory is created at the start of the conversion
 
3388
    process (where # is a number). By default, this is left there on
 
3389
    completion. If the conversion fails, delete the new .bzr directory
 
3390
    and rename this one back in its place. Use the --clean option to ask
 
3391
    for the backup.bzr directory to be removed on successful conversion.
 
3392
    Alternatively, you can delete it by hand if everything looks good
 
3393
    afterwards.
 
3394
 
 
3395
    If the location given is a shared repository, dependent branches
 
3396
    are also converted provided the repository converts successfully.
 
3397
    If the conversion of a branch fails, remaining branches are still
 
3398
    tried.
 
3399
 
 
3400
    For more information on upgrades, see the Bazaar Upgrade Guide,
 
3401
    http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3284
3402
    """
3285
3403
 
3286
 
    _see_also = ['check']
 
3404
    _see_also = ['check', 'reconcile', 'formats']
3287
3405
    takes_args = ['url?']
3288
3406
    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
 
                    ]
 
3407
        RegistryOption('format',
 
3408
            help='Upgrade to a specific format.  See "bzr help'
 
3409
                 ' formats" for details.',
 
3410
            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
 
3411
            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
 
3412
            value_switches=True, title='Branch format'),
 
3413
        Option('clean',
 
3414
            help='Remove the backup.bzr directory if successful.'),
 
3415
        Option('dry-run',
 
3416
            help="Show what would be done, but don't actually do anything."),
 
3417
    ]
3296
3418
 
3297
 
    def run(self, url='.', format=None):
 
3419
    def run(self, url='.', format=None, clean=False, dry_run=False):
3298
3420
        from bzrlib.upgrade import upgrade
3299
 
        upgrade(url, format)
 
3421
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
 
3422
        if exceptions:
 
3423
            if len(exceptions) == 1:
 
3424
                # Compatibility with historical behavior
 
3425
                raise exceptions[0]
 
3426
            else:
 
3427
                return 3
3300
3428
 
3301
3429
 
3302
3430
class cmd_whoami(Command):
3311
3439
 
3312
3440
            bzr whoami "Frank Chu <fchu@example.com>"
3313
3441
    """
3314
 
    takes_options = [ Option('email',
 
3442
    takes_options = [ 'directory',
 
3443
                      Option('email',
3315
3444
                             help='Display email address only.'),
3316
3445
                      Option('branch',
3317
3446
                             help='Set identity for the current branch instead of '
3321
3450
    encoding_type = 'replace'
3322
3451
 
3323
3452
    @display_command
3324
 
    def run(self, email=False, branch=False, name=None):
 
3453
    def run(self, email=False, branch=False, name=None, directory=None):
3325
3454
        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()
 
3455
            if directory is None:
 
3456
                # use branch if we're inside one; otherwise global config
 
3457
                try:
 
3458
                    c = Branch.open_containing(u'.')[0].get_config()
 
3459
                except errors.NotBranchError:
 
3460
                    c = _mod_config.GlobalConfig()
 
3461
            else:
 
3462
                c = Branch.open(directory).get_config()
3331
3463
            if email:
3332
3464
                self.outf.write(c.user_email() + '\n')
3333
3465
            else:
3334
3466
                self.outf.write(c.username() + '\n')
3335
3467
            return
3336
3468
 
 
3469
        if email:
 
3470
            raise errors.BzrCommandError("--email can only be used to display existing "
 
3471
                                         "identity")
 
3472
 
3337
3473
        # display a warning if an email address isn't included in the given name.
3338
3474
        try:
3339
 
            config.extract_email_address(name)
 
3475
            _mod_config.extract_email_address(name)
3340
3476
        except errors.NoEmailInUsername, e:
3341
3477
            warning('"%s" does not seem to contain an email address.  '
3342
3478
                    'This is allowed, but not recommended.', name)
3343
3479
 
3344
3480
        # use global config unless --branch given
3345
3481
        if branch:
3346
 
            c = Branch.open_containing('.')[0].get_config()
 
3482
            if directory is None:
 
3483
                c = Branch.open_containing(u'.')[0].get_config()
 
3484
            else:
 
3485
                c = Branch.open(directory).get_config()
3347
3486
        else:
3348
 
            c = config.GlobalConfig()
 
3487
            c = _mod_config.GlobalConfig()
3349
3488
        c.set_user_option('email', name)
3350
3489
 
3351
3490
 
3418
3557
                'bzr alias --remove expects an alias to remove.')
3419
3558
        # If alias is not found, print something like:
3420
3559
        # unalias: foo: not found
3421
 
        c = config.GlobalConfig()
 
3560
        c = _mod_config.GlobalConfig()
3422
3561
        c.unset_alias(alias_name)
3423
3562
 
3424
3563
    @display_command
3425
3564
    def print_aliases(self):
3426
3565
        """Print out the defined aliases in a similar format to bash."""
3427
 
        aliases = config.GlobalConfig().get_aliases()
 
3566
        aliases = _mod_config.GlobalConfig().get_aliases()
3428
3567
        for key, value in sorted(aliases.iteritems()):
3429
3568
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
3430
3569
 
3440
3579
 
3441
3580
    def set_alias(self, alias_name, alias_command):
3442
3581
        """Save the alias in the global config."""
3443
 
        c = config.GlobalConfig()
 
3582
        c = _mod_config.GlobalConfig()
3444
3583
        c.set_alias(alias_name, alias_command)
3445
3584
 
3446
3585
 
3481
3620
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3482
3621
    into a pdb postmortem session.
3483
3622
 
 
3623
    The --coverage=DIRNAME global option produces a report with covered code
 
3624
    indicated.
 
3625
 
3484
3626
    :Examples:
3485
3627
        Run only tests relating to 'ignore'::
3486
3628
 
3519
3661
                                 'throughout the test suite.',
3520
3662
                            type=get_transport_type),
3521
3663
                     Option('benchmark',
3522
 
                            help='Run the benchmarks rather than selftests.'),
 
3664
                            help='Run the benchmarks rather than selftests.',
 
3665
                            hidden=True),
3523
3666
                     Option('lsprof-timed',
3524
3667
                            help='Generate lsprof output for benchmarked'
3525
3668
                                 ' sections of code.'),
3526
3669
                     Option('lsprof-tests',
3527
3670
                            help='Generate lsprof output for each test.'),
3528
 
                     Option('cache-dir', type=str,
3529
 
                            help='Cache intermediate benchmark output in this '
3530
 
                                 'directory.'),
3531
3671
                     Option('first',
3532
3672
                            help='Run all tests, but run specified tests first.',
3533
3673
                            short_name='f',
3567
3707
 
3568
3708
    def run(self, testspecs_list=None, verbose=False, one=False,
3569
3709
            transport=None, benchmark=None,
3570
 
            lsprof_timed=None, cache_dir=None,
 
3710
            lsprof_timed=None,
3571
3711
            first=False, list_only=False,
3572
3712
            randomize=None, exclude=None, strict=False,
3573
3713
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3574
3714
            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)
 
3715
        from bzrlib import tests
 
3716
 
3584
3717
        if testspecs_list is not None:
3585
3718
            pattern = '|'.join(testspecs_list)
3586
3719
        else:
3594
3727
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3595
3728
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3596
3729
            # stdout, which would corrupt the subunit stream. 
3597
 
            if sys.platform == "win32" and sys.stdout.fileno() >= 0:
 
3730
            # FIXME: This has been fixed in subunit trunk (>0.0.5) so the
 
3731
            # following code can be deleted when it's sufficiently deployed
 
3732
            # -- vila/mgz 20100514
 
3733
            if (sys.platform == "win32"
 
3734
                and getattr(sys.stdout, 'fileno', None) is not None):
3598
3735
                import msvcrt
3599
3736
                msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3600
3737
        if parallel:
3601
3738
            self.additional_selftest_args.setdefault(
3602
3739
                'suite_decorators', []).append(parallel)
3603
3740
        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
 
3741
            raise errors.BzrCommandError(
 
3742
                "--benchmark is no longer supported from bzr 2.2; "
 
3743
                "use bzr-usertest instead")
 
3744
        test_suite_factory = None
3613
3745
        selftest_kwargs = {"verbose": verbose,
3614
3746
                          "pattern": pattern,
3615
3747
                          "stop_on_failure": one,
3617
3749
                          "test_suite_factory": test_suite_factory,
3618
3750
                          "lsprof_timed": lsprof_timed,
3619
3751
                          "lsprof_tests": lsprof_tests,
3620
 
                          "bench_history": benchfile,
3621
3752
                          "matching_tests_first": first,
3622
3753
                          "list_only": list_only,
3623
3754
                          "random_seed": randomize,
3628
3759
                          "starting_with": starting_with
3629
3760
                          }
3630
3761
        selftest_kwargs.update(self.additional_selftest_args)
3631
 
        result = selftest(**selftest_kwargs)
 
3762
 
 
3763
        # Make deprecation warnings visible, unless -Werror is set
 
3764
        cleanup = symbol_versioning.activate_deprecation_warnings(
 
3765
            override=False)
 
3766
        try:
 
3767
            result = tests.selftest(**selftest_kwargs)
 
3768
        finally:
 
3769
            cleanup()
3632
3770
        return int(not result)
3633
3771
 
3634
3772
 
3691
3829
    with bzr send. If neither is specified, the default is the upstream branch
3692
3830
    or the branch most recently merged using --remember.
3693
3831
 
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.
 
3832
    When merging from a branch, by default bzr will try to merge in all new
 
3833
    work from the other branch, automatically determining an appropriate base
 
3834
    revision.  If this fails, you may need to give an explicit base.
 
3835
 
 
3836
    To pick a different ending revision, pass "--revision OTHER".  bzr will
 
3837
    try to merge in all new work up to and including revision OTHER.
 
3838
 
 
3839
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
 
3840
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
 
3841
    causes some revisions to be skipped, i.e. if the destination branch does
 
3842
    not already contain revision BASE, such a merge is commonly referred to as
 
3843
    a "cherrypick".
 
3844
 
 
3845
    Revision numbers are always relative to the source branch.
3704
3846
 
3705
3847
    Merge will do its best to combine the changes in two branches, but there
3706
3848
    are some kinds of problems only a human can fix.  When it encounters those,
3730
3872
    you to apply each diff hunk and file change, similar to "shelve".
3731
3873
 
3732
3874
    :Examples:
3733
 
        To merge the latest revision from bzr.dev::
 
3875
        To merge all new revisions from bzr.dev::
3734
3876
 
3735
3877
            bzr merge ../bzr.dev
3736
3878
 
3881
4023
    def _do_preview(self, merger):
3882
4024
        from bzrlib.diff import show_diff_trees
3883
4025
        result_tree = self._get_preview(merger)
 
4026
        path_encoding = osutils.get_diff_header_encoding()
3884
4027
        show_diff_trees(merger.this_tree, result_tree, self.outf,
3885
 
                        old_label='', new_label='')
 
4028
                        old_label='', new_label='',
 
4029
                        path_encoding=path_encoding)
3886
4030
 
3887
4031
    def _do_merge(self, merger, change_reporter, allow_pending, verified):
3888
4032
        merger.change_reporter = change_reporter
3968
4112
        if ((remember or tree.branch.get_submit_branch() is None) and
3969
4113
             user_location is not None):
3970
4114
            tree.branch.set_submit_branch(other_branch.base)
3971
 
        _merge_tags_if_possible(other_branch, tree.branch)
 
4115
        # Merge tags (but don't set them in the master branch yet, the user
 
4116
        # might revert this merge).  Commit will propagate them.
 
4117
        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3972
4118
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3973
4119
            other_revision_id, base_revision_id, other_branch, base_branch)
3974
4120
        if other_path != '':
4075
4221
        from bzrlib.conflicts import restore
4076
4222
        if merge_type is None:
4077
4223
            merge_type = _mod_merge.Merge3Merger
4078
 
        tree, file_list = tree_files(file_list)
 
4224
        tree, file_list = WorkingTree.open_containing_paths(file_list)
4079
4225
        self.add_cleanup(tree.lock_write().unlock)
4080
4226
        parents = tree.get_parent_ids()
4081
4227
        if len(parents) != 2:
4142
4288
    last committed revision is used.
4143
4289
 
4144
4290
    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.
 
4291
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
 
4292
    will remove the changes introduced by the second last commit (-2), without
 
4293
    affecting the changes introduced by the last commit (-1).  To remove
 
4294
    certain changes on a hunk-by-hunk basis, see the shelve command.
4148
4295
 
4149
4296
    By default, any files that have been manually changed will be backed up
4150
4297
    first.  (Files changed only by merge are not backed up.)  Backup files have
4180
4327
    target branches.
4181
4328
    """
4182
4329
 
4183
 
    _see_also = ['cat', 'export']
 
4330
    _see_also = ['cat', 'export', 'merge', 'shelve']
4184
4331
    takes_options = [
4185
4332
        'revision',
4186
4333
        Option('no-backup', "Do not save backups of reverted files."),
4191
4338
 
4192
4339
    def run(self, revision=None, no_backup=False, file_list=None,
4193
4340
            forget_merges=None):
4194
 
        tree, file_list = tree_files(file_list)
 
4341
        tree, file_list = WorkingTree.open_containing_paths(file_list)
4195
4342
        self.add_cleanup(tree.lock_tree_write().unlock)
4196
4343
        if forget_merges:
4197
4344
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4287
4434
    _see_also = ['merge', 'pull']
4288
4435
    takes_args = ['other_branch?']
4289
4436
    takes_options = [
 
4437
        'directory',
4290
4438
        Option('reverse', 'Reverse the order of revisions.'),
4291
4439
        Option('mine-only',
4292
4440
               'Display changes in the local branch only.'),
4314
4462
            theirs_only=False,
4315
4463
            log_format=None, long=False, short=False, line=False,
4316
4464
            show_ids=False, verbose=False, this=False, other=False,
4317
 
            include_merges=False, revision=None, my_revision=None):
 
4465
            include_merges=False, revision=None, my_revision=None,
 
4466
            directory=u'.'):
4318
4467
        from bzrlib.missing import find_unmerged, iter_log_revisions
4319
4468
        def message(s):
4320
4469
            if not is_quiet():
4333
4482
        elif theirs_only:
4334
4483
            restrict = 'remote'
4335
4484
 
4336
 
        local_branch = Branch.open_containing(u".")[0]
 
4485
        local_branch = Branch.open_containing(directory)[0]
4337
4486
        self.add_cleanup(local_branch.lock_read().unlock)
4338
4487
 
4339
4488
        parent = local_branch.get_parent()
4477
4626
 
4478
4627
    @display_command
4479
4628
    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")
 
4629
        from bzrlib import plugin
 
4630
        self.outf.writelines(
 
4631
            plugin.describe_plugins(show_paths=verbose))
4500
4632
 
4501
4633
 
4502
4634
class cmd_testament(Command):
4564
4696
            self.add_cleanup(branch.lock_read().unlock)
4565
4697
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4566
4698
        self.add_cleanup(tree.lock_read().unlock)
4567
 
        if wt is not None:
 
4699
        if wt is not None and revision is None:
4568
4700
            file_id = wt.path2id(relpath)
4569
4701
        else:
4570
4702
            file_id = tree.path2id(relpath)
4571
4703
        if file_id is None:
4572
4704
            raise errors.NotVersionedError(filename)
4573
 
        file_version = tree.inventory[file_id].revision
4574
4705
        if wt is not None and revision is None:
4575
4706
            # If there is a tree and we're not annotating historical
4576
4707
            # versions, annotate the working tree's content.
4577
4708
            annotate_file_tree(wt, file_id, self.outf, long, all,
4578
4709
                show_ids=show_ids)
4579
4710
        else:
 
4711
            file_version = tree.inventory[file_id].revision
4580
4712
            annotate_file(branch, file_version, file_id, long, all, self.outf,
4581
4713
                          show_ids=show_ids)
4582
4714
 
4798
4930
            self.outf.write('The above revision(s) will be removed.\n')
4799
4931
 
4800
4932
        if not force:
4801
 
            if not ui.ui_factory.get_boolean('Are you sure'):
4802
 
                self.outf.write('Canceled')
 
4933
            if not ui.ui_factory.confirm_action(
 
4934
                    'Uncommit these revisions',
 
4935
                    'bzrlib.builtins.uncommit',
 
4936
                    {}):
 
4937
                self.outf.write('Canceled\n')
4803
4938
                return 0
4804
4939
 
4805
4940
        mutter('Uncommitting from {%s} to {%s}',
4811
4946
 
4812
4947
 
4813
4948
class cmd_break_lock(Command):
4814
 
    __doc__ = """Break a dead lock on a repository, branch or working directory.
 
4949
    __doc__ = """Break a dead lock.
 
4950
 
 
4951
    This command breaks a lock on a repository, branch, working directory or
 
4952
    config file.
4815
4953
 
4816
4954
    CAUTION: Locks should only be broken when you are sure that the process
4817
4955
    holding the lock has been stopped.
4822
4960
    :Examples:
4823
4961
        bzr break-lock
4824
4962
        bzr break-lock bzr+ssh://example.com/bzr/foo
 
4963
        bzr break-lock --conf ~/.bazaar
4825
4964
    """
 
4965
 
4826
4966
    takes_args = ['location?']
 
4967
    takes_options = [
 
4968
        Option('config',
 
4969
               help='LOCATION is the directory where the config lock is.'),
 
4970
        Option('force',
 
4971
            help='Do not ask for confirmation before breaking the lock.'),
 
4972
        ]
4827
4973
 
4828
 
    def run(self, location=None, show=False):
 
4974
    def run(self, location=None, config=False, force=False):
4829
4975
        if location is None:
4830
4976
            location = u'.'
4831
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
4832
 
        try:
4833
 
            control.break_lock()
4834
 
        except NotImplementedError:
4835
 
            pass
 
4977
        if force:
 
4978
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
 
4979
                None,
 
4980
                {'bzrlib.lockdir.break': True})
 
4981
        if config:
 
4982
            conf = _mod_config.LockableConfig(file_name=location)
 
4983
            conf.break_lock()
 
4984
        else:
 
4985
            control, relpath = bzrdir.BzrDir.open_containing(location)
 
4986
            try:
 
4987
                control.break_lock()
 
4988
            except NotImplementedError:
 
4989
                pass
4836
4990
 
4837
4991
 
4838
4992
class cmd_wait_until_signalled(Command):
4901
5055
 
4902
5056
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
4903
5057
            protocol=None):
4904
 
        from bzrlib.transport import get_transport, transport_server_registry
 
5058
        from bzrlib import transport
4905
5059
        if directory is None:
4906
5060
            directory = os.getcwd()
4907
5061
        if protocol is None:
4908
 
            protocol = transport_server_registry.get()
 
5062
            protocol = transport.transport_server_registry.get()
4909
5063
        host, port = self.get_host_and_port(port)
4910
5064
        url = urlutils.local_path_to_url(directory)
4911
5065
        if not allow_writes:
4912
5066
            url = 'readonly+' + url
4913
 
        transport = get_transport(url)
4914
 
        protocol(transport, host, port, inet)
 
5067
        t = transport.get_transport(url)
 
5068
        protocol(t, host, port, inet)
4915
5069
 
4916
5070
 
4917
5071
class cmd_join(Command):
4923
5077
    not part of it.  (Such trees can be produced by "bzr split", but also by
4924
5078
    running "bzr branch" with the target inside a tree.)
4925
5079
 
4926
 
    The result is a combined tree, with the subtree no longer an independant
 
5080
    The result is a combined tree, with the subtree no longer an independent
4927
5081
    part.  This is marked as a merge of the subtree into the containing tree,
4928
5082
    and all history is preserved.
4929
5083
    """
5010
5164
    _see_also = ['send']
5011
5165
 
5012
5166
    takes_options = [
 
5167
        'directory',
5013
5168
        RegistryOption.from_kwargs('patch-type',
5014
5169
            'The type of patch to include in the directive.',
5015
5170
            title='Patch type',
5028
5183
    encoding_type = 'exact'
5029
5184
 
5030
5185
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5031
 
            sign=False, revision=None, mail_to=None, message=None):
 
5186
            sign=False, revision=None, mail_to=None, message=None,
 
5187
            directory=u'.'):
5032
5188
        from bzrlib.revision import ensure_null, NULL_REVISION
5033
5189
        include_patch, include_bundle = {
5034
5190
            'plain': (False, False),
5035
5191
            'diff': (True, False),
5036
5192
            'bundle': (True, True),
5037
5193
            }[patch_type]
5038
 
        branch = Branch.open('.')
 
5194
        branch = Branch.open(directory)
5039
5195
        stored_submit_branch = branch.get_submit_branch()
5040
5196
        if submit_branch is None:
5041
5197
            submit_branch = stored_submit_branch
5126
5282
    given, in which case it is sent to a file.
5127
5283
 
5128
5284
    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.
 
5285
    on Windows (it uses MAPI).  On Unix, it requires the xdg-email utility.
5130
5286
    If the preferred client can't be found (or used), your editor will be used.
5131
5287
 
5132
5288
    To use a specific mail program, set the mail_client configuration option.
5323
5479
            if tag_name is None:
5324
5480
                raise errors.BzrCommandError("No tag specified to delete.")
5325
5481
            branch.tags.delete_tag(tag_name)
5326
 
            self.outf.write('Deleted tag %s.\n' % tag_name)
 
5482
            note('Deleted tag %s.' % tag_name)
5327
5483
        else:
5328
5484
            if revision:
5329
5485
                if len(revision) != 1:
5341
5497
            if (not force) and branch.tags.has_tag(tag_name):
5342
5498
                raise errors.TagAlreadyExists(tag_name)
5343
5499
            branch.tags.set_tag(tag_name, revision_id)
5344
 
            self.outf.write('Created tag %s.\n' % tag_name)
 
5500
            note('Created tag %s.' % tag_name)
5345
5501
 
5346
5502
 
5347
5503
class cmd_tags(Command):
5354
5510
    takes_options = [
5355
5511
        custom_help('directory',
5356
5512
            help='Branch whose tags should be displayed.'),
5357
 
        RegistryOption.from_kwargs('sort',
 
5513
        RegistryOption('sort',
5358
5514
            'Sort tags by different criteria.', title='Sorting',
5359
 
            alpha='Sort tags lexicographically (default).',
5360
 
            time='Sort tags chronologically.',
 
5515
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5361
5516
            ),
5362
5517
        'show-ids',
5363
5518
        'revision',
5364
5519
    ]
5365
5520
 
5366
5521
    @display_command
5367
 
    def run(self,
5368
 
            directory='.',
5369
 
            sort='alpha',
5370
 
            show_ids=False,
5371
 
            revision=None,
5372
 
            ):
 
5522
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
 
5523
        from bzrlib.tag import tag_sort_methods
5373
5524
        branch, relpath = Branch.open_containing(directory)
5374
5525
 
5375
5526
        tags = branch.tags.get_tag_dict().items()
5384
5535
            # only show revisions between revid1 and revid2 (inclusive)
5385
5536
            tags = [(tag, revid) for tag, revid in tags if
5386
5537
                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]])
 
5538
        if sort is None:
 
5539
            sort = tag_sort_methods.get()
 
5540
        sort(branch, tags)
5400
5541
        if not show_ids:
5401
5542
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5402
5543
            for index, (tag, revid) in enumerate(tags):
5404
5545
                    revno = branch.revision_id_to_dotted_revno(revid)
5405
5546
                    if isinstance(revno, tuple):
5406
5547
                        revno = '.'.join(map(str, revno))
5407
 
                except errors.NoSuchRevision:
 
5548
                except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
5408
5549
                    # Bad tag data/merges can lead to tagged revisions
5409
5550
                    # which are not in this branch. Fail gracefully ...
5410
5551
                    revno = '?'
5529
5670
    """
5530
5671
 
5531
5672
    takes_args = ['to_location?']
5532
 
    takes_options = [Option('force',
 
5673
    takes_options = ['directory',
 
5674
                     Option('force',
5533
5675
                        help='Switch even if local commits will be lost.'),
5534
5676
                     'revision',
5535
5677
                     Option('create-branch', short_name='b',
5538
5680
                    ]
5539
5681
 
5540
5682
    def run(self, to_location=None, force=False, create_branch=False,
5541
 
            revision=None):
 
5683
            revision=None, directory=u'.'):
5542
5684
        from bzrlib import switch
5543
 
        tree_location = '.'
 
5685
        tree_location = directory
5544
5686
        revision = _get_one_revision('switch', revision)
5545
5687
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5546
5688
        if to_location is None:
5547
5689
            if revision is None:
5548
5690
                raise errors.BzrCommandError('You must supply either a'
5549
5691
                                             ' revision or a location')
5550
 
            to_location = '.'
 
5692
            to_location = tree_location
5551
5693
        try:
5552
5694
            branch = control_dir.open_branch()
5553
5695
            had_explicit_nick = branch.get_config().has_explicit_nickname()
5688
5830
            name=None,
5689
5831
            switch=None,
5690
5832
            ):
5691
 
        tree, file_list = tree_files(file_list, apply_view=False)
 
5833
        tree, file_list = WorkingTree.open_containing_paths(file_list,
 
5834
            apply_view=False)
5692
5835
        current_view, view_dict = tree.views.get_view_info()
5693
5836
        if name is None:
5694
5837
            name = current_view
5798
5941
            location = "."
5799
5942
        branch = Branch.open_containing(location)[0]
5800
5943
        branch.bzrdir.destroy_branch()
5801
 
        
 
5944
 
5802
5945
 
5803
5946
class cmd_shelve(Command):
5804
5947
    __doc__ = """Temporarily set aside some changes from the current tree.
5823
5966
 
5824
5967
    You can put multiple items on the shelf, and by default, 'unshelve' will
5825
5968
    restore the most recently shelved changes.
 
5969
 
 
5970
    For complicated changes, it is possible to edit the changes in a separate
 
5971
    editor program to decide what the file remaining in the working copy
 
5972
    should look like.  To do this, add the configuration option
 
5973
 
 
5974
        change_editor = PROGRAM @new_path @old_path
 
5975
 
 
5976
    where @new_path is replaced with the path of the new version of the 
 
5977
    file and @old_path is replaced with the path of the old version of 
 
5978
    the file.  The PROGRAM should save the new file with the desired 
 
5979
    contents of the file in the working tree.
 
5980
        
5826
5981
    """
5827
5982
 
5828
5983
    takes_args = ['file*']
5829
5984
 
5830
5985
    takes_options = [
 
5986
        'directory',
5831
5987
        'revision',
5832
5988
        Option('all', help='Shelve all changes.'),
5833
5989
        'message',
5839
5995
        Option('destroy',
5840
5996
               help='Destroy removed changes instead of shelving them.'),
5841
5997
    ]
5842
 
    _see_also = ['unshelve']
 
5998
    _see_also = ['unshelve', 'configuration']
5843
5999
 
5844
6000
    def run(self, revision=None, all=False, file_list=None, message=None,
5845
 
            writer=None, list=False, destroy=False):
 
6001
            writer=None, list=False, destroy=False, directory=None):
5846
6002
        if list:
5847
 
            return self.run_for_list()
 
6003
            return self.run_for_list(directory=directory)
5848
6004
        from bzrlib.shelf_ui import Shelver
5849
6005
        if writer is None:
5850
6006
            writer = bzrlib.option.diff_writer_registry.get()
5851
6007
        try:
5852
6008
            shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5853
 
                file_list, message, destroy=destroy)
 
6009
                file_list, message, destroy=destroy, directory=directory)
5854
6010
            try:
5855
6011
                shelver.run()
5856
6012
            finally:
5858
6014
        except errors.UserAbort:
5859
6015
            return 0
5860
6016
 
5861
 
    def run_for_list(self):
5862
 
        tree = WorkingTree.open_containing('.')[0]
 
6017
    def run_for_list(self, directory=None):
 
6018
        if directory is None:
 
6019
            directory = u'.'
 
6020
        tree = WorkingTree.open_containing(directory)[0]
5863
6021
        self.add_cleanup(tree.lock_read().unlock)
5864
6022
        manager = tree.get_shelf_manager()
5865
6023
        shelves = manager.active_shelves()
5884
6042
 
5885
6043
    takes_args = ['shelf_id?']
5886
6044
    takes_options = [
 
6045
        'directory',
5887
6046
        RegistryOption.from_kwargs(
5888
6047
            'action', help="The action to perform.",
5889
6048
            enum_switch=False, value_switches=True,
5897
6056
    ]
5898
6057
    _see_also = ['shelve']
5899
6058
 
5900
 
    def run(self, shelf_id=None, action='apply'):
 
6059
    def run(self, shelf_id=None, action='apply', directory=u'.'):
5901
6060
        from bzrlib.shelf_ui import Unshelver
5902
 
        unshelver = Unshelver.from_args(shelf_id, action)
 
6061
        unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5903
6062
        try:
5904
6063
            unshelver.run()
5905
6064
        finally:
5923
6082
    """
5924
6083
    takes_options = ['directory',
5925
6084
                     Option('ignored', help='Delete all ignored files.'),
5926
 
                     Option('detritus', help='Delete conflict files, merge'
 
6085
                     Option('detritus', help='Delete conflict files, merge and revert'
5927
6086
                            ' backups, and failed selftest dirs.'),
5928
6087
                     Option('unknown',
5929
6088
                            help='Delete files unknown to bzr (default).'),
5993
6152
    # be only called once.
5994
6153
    for (name, aliases, module_name) in [
5995
6154
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
 
6155
        ('cmd_config', [], 'bzrlib.config'),
5996
6156
        ('cmd_dpush', [], 'bzrlib.foreign'),
5997
6157
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
5998
6158
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
5999
6159
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6000
6160
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
 
6161
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6001
6162
        ]:
6002
6163
        builtin_command_registry.register_lazy(name, aliases, module_name)