/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: Martin von Gagern
  • Date: 2011-09-19 08:49:15 UTC
  • mto: This revision was merged to the branch mainline in revision 6148.
  • Revision ID: martin.vgagern@gmx.net-20110919084915-vbumflqq3xqm1vez
Avoid using deprecated api in the unit tests for bzrlib.missing.

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,
45
44
    rename_map,
46
45
    revision as _mod_revision,
47
46
    static_tuple,
48
 
    symbol_versioning,
49
47
    timestamp,
50
48
    transport,
51
49
    ui,
52
50
    urlutils,
53
51
    views,
 
52
    gpg,
54
53
    )
55
54
from bzrlib.branch import Branch
56
55
from bzrlib.conflicts import ConflictList
73
72
    _parse_revision_str,
74
73
    )
75
74
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
76
 
 
77
 
 
 
75
from bzrlib import (
 
76
    symbol_versioning,
 
77
    )
 
78
 
 
79
 
 
80
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
78
81
def tree_files(file_list, default_branch=u'.', canonicalize=True,
79
82
    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]))
 
83
    return internal_tree_files(file_list, default_branch, canonicalize,
 
84
        apply_view)
86
85
 
87
86
 
88
87
def tree_files_for_add(file_list):
152
151
 
153
152
# XXX: Bad function name; should possibly also be a class method of
154
153
# WorkingTree rather than a function.
 
154
@symbol_versioning.deprecated_function(symbol_versioning.deprecated_in((2, 3, 0)))
155
155
def internal_tree_files(file_list, default_branch=u'.', canonicalize=True,
156
156
    apply_view=True):
157
157
    """Convert command-line paths to a WorkingTree and relative paths.
158
158
 
 
159
    Deprecated: use WorkingTree.open_containing_paths instead.
 
160
 
159
161
    This is typically used for command-line processors that take one or
160
162
    more filenames, and infer the workingtree that contains them.
161
163
 
171
173
 
172
174
    :return: workingtree, [relative_paths]
173
175
    """
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
 
176
    return WorkingTree.open_containing_paths(
 
177
        file_list, default_directory='.',
 
178
        canonicalize=True,
 
179
        apply_view=True)
221
180
 
222
181
 
223
182
def _get_view_info_for_change_reporter(tree):
232
191
    return view_info
233
192
 
234
193
 
 
194
def _open_directory_or_containing_tree_or_branch(filename, directory):
 
195
    """Open the tree or branch containing the specified file, unless
 
196
    the --directory option is used to specify a different branch."""
 
197
    if directory is not None:
 
198
        return (None, Branch.open(directory), filename)
 
199
    return bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
200
 
 
201
 
235
202
# TODO: Make sure no commands unconditionally use the working directory as a
236
203
# branch.  If a filename argument is used, the first of them should be used to
237
204
# specify the branch.  (Perhaps this can be factored out into some kind of
265
232
    unknown
266
233
        Not versioned and not matching an ignore pattern.
267
234
 
268
 
    Additionally for directories, symlinks and files with an executable
269
 
    bit, Bazaar indicates their type using a trailing character: '/', '@'
270
 
    or '*' respectively.
 
235
    Additionally for directories, symlinks and files with a changed
 
236
    executable bit, Bazaar indicates their type using a trailing
 
237
    character: '/', '@' or '*' respectively. These decorations can be
 
238
    disabled using the '--no-classify' option.
271
239
 
272
240
    To see ignored files use 'bzr ignored'.  For details on the
273
241
    changes to file texts, use 'bzr diff'.
286
254
    To skip the display of pending merge information altogether, use
287
255
    the no-pending option or specify a file/directory.
288
256
 
289
 
    If a revision argument is given, the status is calculated against
290
 
    that revision, or between two revisions if two are provided.
 
257
    To compare the working directory to a specific revision, pass a
 
258
    single revision to the revision argument.
 
259
 
 
260
    To see which files have changed in a specific revision, or between
 
261
    two revisions, pass a revision range to the revision argument.
 
262
    This will produce the same results as calling 'bzr diff --summarize'.
291
263
    """
292
264
 
293
265
    # TODO: --no-recurse, --recurse options
300
272
                            short_name='V'),
301
273
                     Option('no-pending', help='Don\'t show pending merges.',
302
274
                           ),
 
275
                     Option('no-classify',
 
276
                            help='Do not mark object type using indicator.',
 
277
                           ),
303
278
                     ]
304
279
    aliases = ['st', 'stat']
305
280
 
308
283
 
309
284
    @display_command
310
285
    def run(self, show_ids=False, file_list=None, revision=None, short=False,
311
 
            versioned=False, no_pending=False, verbose=False):
 
286
            versioned=False, no_pending=False, verbose=False,
 
287
            no_classify=False):
312
288
        from bzrlib.status import show_tree_status
313
289
 
314
290
        if revision and len(revision) > 2:
315
291
            raise errors.BzrCommandError('bzr status --revision takes exactly'
316
292
                                         ' one or two revision specifiers')
317
293
 
318
 
        tree, relfile_list = tree_files(file_list)
 
294
        tree, relfile_list = WorkingTree.open_containing_paths(file_list)
319
295
        # Avoid asking for specific files when that is not needed.
320
296
        if relfile_list == ['']:
321
297
            relfile_list = None
328
304
        show_tree_status(tree, show_ids=show_ids,
329
305
                         specific_files=relfile_list, revision=revision,
330
306
                         to_file=self.outf, short=short, versioned=versioned,
331
 
                         show_pending=(not no_pending), verbose=verbose)
 
307
                         show_pending=(not no_pending), verbose=verbose,
 
308
                         classify=not no_classify)
332
309
 
333
310
 
334
311
class cmd_cat_revision(Command):
340
317
 
341
318
    hidden = True
342
319
    takes_args = ['revision_id?']
343
 
    takes_options = ['revision']
 
320
    takes_options = ['directory', 'revision']
344
321
    # cat-revision is more for frontends so should be exact
345
322
    encoding = 'strict'
346
323
 
353
330
        self.outf.write(revtext.decode('utf-8'))
354
331
 
355
332
    @display_command
356
 
    def run(self, revision_id=None, revision=None):
 
333
    def run(self, revision_id=None, revision=None, directory=u'.'):
357
334
        if revision_id is not None and revision is not None:
358
335
            raise errors.BzrCommandError('You can only supply one of'
359
336
                                         ' revision_id or --revision')
360
337
        if revision_id is None and revision is None:
361
338
            raise errors.BzrCommandError('You must supply either'
362
339
                                         ' --revision or a revision_id')
363
 
        b = WorkingTree.open_containing(u'.')[0].branch
 
340
 
 
341
        b = bzrdir.BzrDir.open_containing_tree_or_branch(directory)[1]
364
342
 
365
343
        revisions = b.repository.revisions
366
344
        if revisions is None:
444
422
                self.outf.write(page_bytes[:header_end])
445
423
                page_bytes = data
446
424
            self.outf.write('\nPage %d\n' % (page_idx,))
447
 
            decomp_bytes = zlib.decompress(page_bytes)
448
 
            self.outf.write(decomp_bytes)
449
 
            self.outf.write('\n')
 
425
            if len(page_bytes) == 0:
 
426
                self.outf.write('(empty)\n');
 
427
            else:
 
428
                decomp_bytes = zlib.decompress(page_bytes)
 
429
                self.outf.write(decomp_bytes)
 
430
                self.outf.write('\n')
450
431
 
451
432
    def _dump_entries(self, trans, basename):
452
433
        try:
483
464
    takes_options = [
484
465
        Option('force',
485
466
               help='Remove the working tree even if it has '
486
 
                    'uncommitted changes.'),
 
467
                    'uncommitted or shelved changes.'),
487
468
        ]
488
469
 
489
470
    def run(self, location_list, force=False):
503
484
            if not force:
504
485
                if (working.has_changes()):
505
486
                    raise errors.UncommittedChanges(working)
 
487
                if working.get_shelf_manager().last_shelf() is not None:
 
488
                    raise errors.ShelvedChanges(working)
506
489
 
507
490
            if working.user_url != working.branch.user_url:
508
491
                raise errors.BzrCommandError("You cannot remove the working tree"
511
494
            d.destroy_workingtree()
512
495
 
513
496
 
 
497
class cmd_repair_workingtree(Command):
 
498
    __doc__ = """Reset the working tree state file.
 
499
 
 
500
    This is not meant to be used normally, but more as a way to recover from
 
501
    filesystem corruption, etc. This rebuilds the working inventory back to a
 
502
    'known good' state. Any new modifications (adding a file, renaming, etc)
 
503
    will be lost, though modified files will still be detected as such.
 
504
 
 
505
    Most users will want something more like "bzr revert" or "bzr update"
 
506
    unless the state file has become corrupted.
 
507
 
 
508
    By default this attempts to recover the current state by looking at the
 
509
    headers of the state file. If the state file is too corrupted to even do
 
510
    that, you can supply --revision to force the state of the tree.
 
511
    """
 
512
 
 
513
    takes_options = ['revision', 'directory',
 
514
        Option('force',
 
515
               help='Reset the tree even if it doesn\'t appear to be'
 
516
                    ' corrupted.'),
 
517
    ]
 
518
    hidden = True
 
519
 
 
520
    def run(self, revision=None, directory='.', force=False):
 
521
        tree, _ = WorkingTree.open_containing(directory)
 
522
        self.add_cleanup(tree.lock_tree_write().unlock)
 
523
        if not force:
 
524
            try:
 
525
                tree.check_state()
 
526
            except errors.BzrError:
 
527
                pass # There seems to be a real error here, so we'll reset
 
528
            else:
 
529
                # Refuse
 
530
                raise errors.BzrCommandError(
 
531
                    'The tree does not appear to be corrupt. You probably'
 
532
                    ' want "bzr revert" instead. Use "--force" if you are'
 
533
                    ' sure you want to reset the working tree.')
 
534
        if revision is None:
 
535
            revision_ids = None
 
536
        else:
 
537
            revision_ids = [r.as_revision_id(tree.branch) for r in revision]
 
538
        try:
 
539
            tree.reset_state(revision_ids)
 
540
        except errors.BzrError, e:
 
541
            if revision_ids is None:
 
542
                extra = (', the header appears corrupt, try passing -r -1'
 
543
                         ' to set the state to the last commit')
 
544
            else:
 
545
                extra = ''
 
546
            raise errors.BzrCommandError('failed to reset the tree state'
 
547
                                         + extra)
 
548
 
 
549
 
514
550
class cmd_revno(Command):
515
551
    __doc__ = """Show current revision number.
516
552
 
528
564
        if tree:
529
565
            try:
530
566
                wt = WorkingTree.open_containing(location)[0]
531
 
                wt.lock_read()
 
567
                self.add_cleanup(wt.lock_read().unlock)
532
568
            except (errors.NoWorkingTree, errors.NotLocalUrl):
533
569
                raise errors.NoWorkingTree(location)
534
 
            self.add_cleanup(wt.unlock)
535
570
            revid = wt.last_revision()
536
571
            try:
537
572
                revno_t = wt.branch.revision_id_to_dotted_revno(revid)
540
575
            revno = ".".join(str(n) for n in revno_t)
541
576
        else:
542
577
            b = Branch.open_containing(location)[0]
543
 
            b.lock_read()
544
 
            self.add_cleanup(b.unlock)
 
578
            self.add_cleanup(b.lock_read().unlock)
545
579
            revno = b.revno()
546
580
        self.cleanup_now()
547
581
        self.outf.write(str(revno) + '\n')
554
588
    takes_args = ['revision_info*']
555
589
    takes_options = [
556
590
        'revision',
557
 
        Option('directory',
 
591
        custom_help('directory',
558
592
            help='Branch to examine, '
559
 
                 'rather than the one containing the working directory.',
560
 
            short_name='d',
561
 
            type=unicode,
562
 
            ),
 
593
                 'rather than the one containing the working directory.'),
563
594
        Option('tree', help='Show revno of working tree'),
564
595
        ]
565
596
 
570
601
        try:
571
602
            wt = WorkingTree.open_containing(directory)[0]
572
603
            b = wt.branch
573
 
            wt.lock_read()
574
 
            self.add_cleanup(wt.unlock)
 
604
            self.add_cleanup(wt.lock_read().unlock)
575
605
        except (errors.NoWorkingTree, errors.NotLocalUrl):
576
606
            wt = None
577
607
            b = Branch.open_containing(directory)[0]
578
 
            b.lock_read()
579
 
            self.add_cleanup(b.unlock)
 
608
            self.add_cleanup(b.lock_read().unlock)
580
609
        revision_ids = []
581
610
        if revision is not None:
582
611
            revision_ids.extend(rev.as_revision_id(b) for rev in revision)
645
674
    
646
675
    Any files matching patterns in the ignore list will not be added
647
676
    unless they are explicitly mentioned.
 
677
    
 
678
    In recursive mode, files larger than the configuration option 
 
679
    add.maximum_file_size will be skipped. Named items are never skipped due
 
680
    to file size.
648
681
    """
649
682
    takes_args = ['file*']
650
683
    takes_options = [
677
710
            action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
678
711
                          to_file=self.outf, should_print=(not is_quiet()))
679
712
        else:
680
 
            action = bzrlib.add.AddAction(to_file=self.outf,
 
713
            action = bzrlib.add.AddWithSkipLargeAction(to_file=self.outf,
681
714
                should_print=(not is_quiet()))
682
715
 
683
716
        if base_tree:
684
 
            base_tree.lock_read()
685
 
            self.add_cleanup(base_tree.unlock)
 
717
            self.add_cleanup(base_tree.lock_read().unlock)
686
718
        tree, file_list = tree_files_for_add(file_list)
687
719
        added, ignored = tree.smart_add(file_list, not
688
720
            no_recurse, action=action, save=not dry_run)
759
791
            raise errors.BzrCommandError('invalid kind %r specified' % (kind,))
760
792
 
761
793
        revision = _get_one_revision('inventory', revision)
762
 
        work_tree, file_list = tree_files(file_list)
763
 
        work_tree.lock_read()
764
 
        self.add_cleanup(work_tree.unlock)
 
794
        work_tree, file_list = WorkingTree.open_containing_paths(file_list)
 
795
        self.add_cleanup(work_tree.lock_read().unlock)
765
796
        if revision is not None:
766
797
            tree = revision.as_tree(work_tree.branch)
767
798
 
768
799
            extra_trees = [work_tree]
769
 
            tree.lock_read()
770
 
            self.add_cleanup(tree.unlock)
 
800
            self.add_cleanup(tree.lock_read().unlock)
771
801
        else:
772
802
            tree = work_tree
773
803
            extra_trees = []
777
807
                                      require_versioned=True)
778
808
            # find_ids_across_trees may include some paths that don't
779
809
            # exist in 'tree'.
780
 
            entries = sorted((tree.id2path(file_id), tree.inventory[file_id])
781
 
                             for file_id in file_ids if file_id in tree)
 
810
            entries = sorted(
 
811
                (tree.id2path(file_id), tree.inventory[file_id])
 
812
                for file_id in file_ids if tree.has_id(file_id))
782
813
        else:
783
814
            entries = tree.inventory.entries()
784
815
 
832
863
            names_list = []
833
864
        if len(names_list) < 2:
834
865
            raise errors.BzrCommandError("missing file argument")
835
 
        tree, rel_names = tree_files(names_list, canonicalize=False)
836
 
        tree.lock_tree_write()
837
 
        self.add_cleanup(tree.unlock)
 
866
        tree, rel_names = WorkingTree.open_containing_paths(names_list, canonicalize=False)
 
867
        self.add_cleanup(tree.lock_tree_write().unlock)
838
868
        self._run(tree, names_list, rel_names, after)
839
869
 
840
870
    def run_auto(self, names_list, after, dry_run):
844
874
        if after:
845
875
            raise errors.BzrCommandError('--after cannot be specified with'
846
876
                                         ' --auto.')
847
 
        work_tree, file_list = tree_files(names_list, default_branch='.')
848
 
        work_tree.lock_tree_write()
849
 
        self.add_cleanup(work_tree.unlock)
 
877
        work_tree, file_list = WorkingTree.open_containing_paths(
 
878
            names_list, default_directory='.')
 
879
        self.add_cleanup(work_tree.lock_tree_write().unlock)
850
880
        rename_map.RenameMap.guess_renames(work_tree, dry_run)
851
881
 
852
882
    def _run(self, tree, names_list, rel_names, after):
946
976
    match the remote one, use pull --overwrite. This will work even if the two
947
977
    branches have diverged.
948
978
 
949
 
    If there is no default location set, the first pull will set it.  After
950
 
    that, you can omit the location to use the default.  To change the
951
 
    default, use --remember. The value will only be saved if the remote
952
 
    location can be accessed.
 
979
    If there is no default location set, the first pull will set it (use
 
980
    --no-remember to avoid setting it). After that, you can omit the
 
981
    location to use the default.  To change the default, use --remember. The
 
982
    value will only be saved if the remote location can be accessed.
953
983
 
954
984
    Note: The location can be specified either in the form of a branch,
955
985
    or in the form of a path to a file containing a merge directive generated
960
990
    takes_options = ['remember', 'overwrite', 'revision',
961
991
        custom_help('verbose',
962
992
            help='Show logs of pulled revisions.'),
963
 
        Option('directory',
 
993
        custom_help('directory',
964
994
            help='Branch to pull into, '
965
 
                 'rather than the one containing the working directory.',
966
 
            short_name='d',
967
 
            type=unicode,
968
 
            ),
 
995
                 'rather than the one containing the working directory.'),
969
996
        Option('local',
970
997
            help="Perform a local pull in a bound "
971
998
                 "branch.  Local pulls are not applied to "
972
999
                 "the master branch."
973
1000
            ),
 
1001
        Option('show-base',
 
1002
            help="Show base revision text in conflicts.")
974
1003
        ]
975
1004
    takes_args = ['location?']
976
1005
    encoding_type = 'replace'
977
1006
 
978
 
    def run(self, location=None, remember=False, overwrite=False,
 
1007
    def run(self, location=None, remember=None, overwrite=False,
979
1008
            revision=None, verbose=False,
980
 
            directory=None, local=False):
 
1009
            directory=None, local=False,
 
1010
            show_base=False):
981
1011
        # FIXME: too much stuff is in the command class
982
1012
        revision_id = None
983
1013
        mergeable = None
986
1016
        try:
987
1017
            tree_to = WorkingTree.open_containing(directory)[0]
988
1018
            branch_to = tree_to.branch
989
 
            tree_to.lock_write()
990
 
            self.add_cleanup(tree_to.unlock)
 
1019
            self.add_cleanup(tree_to.lock_write().unlock)
991
1020
        except errors.NoWorkingTree:
992
1021
            tree_to = None
993
1022
            branch_to = Branch.open_containing(directory)[0]
994
 
            branch_to.lock_write()
995
 
            self.add_cleanup(branch_to.unlock)
 
1023
            self.add_cleanup(branch_to.lock_write().unlock)
 
1024
 
 
1025
        if tree_to is None and show_base:
 
1026
            raise errors.BzrCommandError("Need working tree for --show-base.")
996
1027
 
997
1028
        if local and not branch_to.get_bound_location():
998
1029
            raise errors.LocalRequiresBoundBranch()
1029
1060
        else:
1030
1061
            branch_from = Branch.open(location,
1031
1062
                possible_transports=possible_transports)
1032
 
            branch_from.lock_read()
1033
 
            self.add_cleanup(branch_from.unlock)
1034
 
 
1035
 
            if branch_to.get_parent() is None or remember:
 
1063
            self.add_cleanup(branch_from.lock_read().unlock)
 
1064
            # Remembers if asked explicitly or no previous location is set
 
1065
            if (remember
 
1066
                or (remember is None and branch_to.get_parent() is None)):
1036
1067
                branch_to.set_parent(branch_from.base)
1037
1068
 
1038
1069
        if revision is not None:
1045
1076
                view_info=view_info)
1046
1077
            result = tree_to.pull(
1047
1078
                branch_from, overwrite, revision_id, change_reporter,
1048
 
                possible_transports=possible_transports, local=local)
 
1079
                local=local, show_base=show_base)
1049
1080
        else:
1050
1081
            result = branch_to.pull(
1051
1082
                branch_from, overwrite, revision_id, local=local)
1055
1086
            log.show_branch_change(
1056
1087
                branch_to, self.outf, result.old_revno,
1057
1088
                result.old_revid)
 
1089
        if getattr(result, 'tag_conflicts', None):
 
1090
            return 1
 
1091
        else:
 
1092
            return 0
1058
1093
 
1059
1094
 
1060
1095
class cmd_push(Command):
1077
1112
    do a merge (see bzr help merge) from the other branch, and commit that.
1078
1113
    After that you will be able to do a push without '--overwrite'.
1079
1114
 
1080
 
    If there is no default push location set, the first push will set it.
1081
 
    After that, you can omit the location to use the default.  To change the
1082
 
    default, use --remember. The value will only be saved if the remote
1083
 
    location can be accessed.
 
1115
    If there is no default push location set, the first push will set it (use
 
1116
    --no-remember to avoid setting it).  After that, you can omit the
 
1117
    location to use the default.  To change the default, use --remember. The
 
1118
    value will only be saved if the remote location can be accessed.
1084
1119
    """
1085
1120
 
1086
1121
    _see_also = ['pull', 'update', 'working-trees']
1088
1123
        Option('create-prefix',
1089
1124
               help='Create the path leading up to the branch '
1090
1125
                    'if it does not already exist.'),
1091
 
        Option('directory',
 
1126
        custom_help('directory',
1092
1127
            help='Branch to push from, '
1093
 
                 'rather than the one containing the working directory.',
1094
 
            short_name='d',
1095
 
            type=unicode,
1096
 
            ),
 
1128
                 'rather than the one containing the working directory.'),
1097
1129
        Option('use-existing-dir',
1098
1130
               help='By default push will fail if the target'
1099
1131
                    ' directory exists, but does not already'
1110
1142
        Option('strict',
1111
1143
               help='Refuse to push if there are uncommitted changes in'
1112
1144
               ' the working tree, --no-strict disables the check.'),
 
1145
        Option('no-tree',
 
1146
               help="Don't populate the working tree, even for protocols"
 
1147
               " that support it."),
1113
1148
        ]
1114
1149
    takes_args = ['location?']
1115
1150
    encoding_type = 'replace'
1116
1151
 
1117
 
    def run(self, location=None, remember=False, overwrite=False,
 
1152
    def run(self, location=None, remember=None, overwrite=False,
1118
1153
        create_prefix=False, verbose=False, revision=None,
1119
1154
        use_existing_dir=False, directory=None, stacked_on=None,
1120
 
        stacked=False, strict=None):
 
1155
        stacked=False, strict=None, no_tree=False):
1121
1156
        from bzrlib.push import _show_push_branch
1122
1157
 
1123
1158
        if directory is None:
1163
1198
            else:
1164
1199
                display_url = urlutils.unescape_for_display(stored_loc,
1165
1200
                        self.outf.encoding)
1166
 
                self.outf.write("Using saved push location: %s\n" % display_url)
 
1201
                note("Using saved push location: %s" % display_url)
1167
1202
                location = stored_loc
1168
1203
 
1169
1204
        _show_push_branch(br_from, revision_id, location, self.outf,
1170
1205
            verbose=verbose, overwrite=overwrite, remember=remember,
1171
1206
            stacked_on=stacked_on, create_prefix=create_prefix,
1172
 
            use_existing_dir=use_existing_dir)
 
1207
            use_existing_dir=use_existing_dir, no_tree=no_tree)
1173
1208
 
1174
1209
 
1175
1210
class cmd_branch(Command):
1184
1219
 
1185
1220
    To retrieve the branch as of a particular revision, supply the --revision
1186
1221
    parameter, as in "branch foo/bar -r 5".
 
1222
 
 
1223
    The synonyms 'clone' and 'get' for this command are deprecated.
1187
1224
    """
1188
1225
 
1189
1226
    _see_also = ['checkout']
1190
1227
    takes_args = ['from_location', 'to_location?']
1191
 
    takes_options = ['revision', Option('hardlink',
1192
 
        help='Hard-link working tree files where possible.'),
 
1228
    takes_options = ['revision',
 
1229
        Option('hardlink', help='Hard-link working tree files where possible.'),
 
1230
        Option('files-from', type=str,
 
1231
               help="Get file contents from this tree."),
1193
1232
        Option('no-tree',
1194
1233
            help="Create a branch without a working-tree."),
1195
1234
        Option('switch',
1213
1252
 
1214
1253
    def run(self, from_location, to_location=None, revision=None,
1215
1254
            hardlink=False, stacked=False, standalone=False, no_tree=False,
1216
 
            use_existing_dir=False, switch=False, bind=False):
 
1255
            use_existing_dir=False, switch=False, bind=False,
 
1256
            files_from=None):
1217
1257
        from bzrlib import switch as _mod_switch
1218
1258
        from bzrlib.tag import _merge_tags_if_possible
 
1259
        if self.invoked_as in ['get', 'clone']:
 
1260
            ui.ui_factory.show_user_warning(
 
1261
                'deprecated_command',
 
1262
                deprecated_name=self.invoked_as,
 
1263
                recommended_name='branch',
 
1264
                deprecated_in_version='2.4')
1219
1265
        accelerator_tree, br_from = bzrdir.BzrDir.open_tree_or_branch(
1220
1266
            from_location)
 
1267
        if not (hardlink or files_from):
 
1268
            # accelerator_tree is usually slower because you have to read N
 
1269
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1270
            # explicitly request it
 
1271
            accelerator_tree = None
 
1272
        if files_from is not None and files_from != from_location:
 
1273
            accelerator_tree = WorkingTree.open(files_from)
1221
1274
        revision = _get_one_revision('branch', revision)
1222
 
        br_from.lock_read()
1223
 
        self.add_cleanup(br_from.unlock)
 
1275
        self.add_cleanup(br_from.lock_read().unlock)
1224
1276
        if revision is not None:
1225
1277
            revision_id = revision.as_revision_id(br_from)
1226
1278
        else:
1285
1337
                urlutils.unescape_for_display(branch.base, 'utf-8'))
1286
1338
 
1287
1339
 
 
1340
class cmd_branches(Command):
 
1341
    __doc__ = """List the branches available at the current location.
 
1342
 
 
1343
    This command will print the names of all the branches at the current location.
 
1344
    """
 
1345
 
 
1346
    takes_args = ['location?']
 
1347
 
 
1348
    def run(self, location="."):
 
1349
        dir = bzrdir.BzrDir.open_containing(location)[0]
 
1350
        for branch in dir.list_branches():
 
1351
            if branch.name is None:
 
1352
                self.outf.write(" (default)\n")
 
1353
            else:
 
1354
                self.outf.write(" %s\n" % branch.name.encode(self.outf.encoding))
 
1355
 
 
1356
 
1288
1357
class cmd_checkout(Command):
1289
1358
    __doc__ = """Create a new checkout of an existing branch.
1290
1359
 
1331
1400
            to_location = branch_location
1332
1401
        accelerator_tree, source = bzrdir.BzrDir.open_tree_or_branch(
1333
1402
            branch_location)
 
1403
        if not (hardlink or files_from):
 
1404
            # accelerator_tree is usually slower because you have to read N
 
1405
            # files (no readahead, lots of seeks, etc), but allow the user to
 
1406
            # explicitly request it
 
1407
            accelerator_tree = None
1334
1408
        revision = _get_one_revision('checkout', revision)
1335
 
        if files_from is not None:
 
1409
        if files_from is not None and files_from != branch_location:
1336
1410
            accelerator_tree = WorkingTree.open(files_from)
1337
1411
        if revision is not None:
1338
1412
            revision_id = revision.as_revision_id(source)
1366
1440
    @display_command
1367
1441
    def run(self, dir=u'.'):
1368
1442
        tree = WorkingTree.open_containing(dir)[0]
1369
 
        tree.lock_read()
1370
 
        self.add_cleanup(tree.unlock)
 
1443
        self.add_cleanup(tree.lock_read().unlock)
1371
1444
        new_inv = tree.inventory
1372
1445
        old_tree = tree.basis_tree()
1373
 
        old_tree.lock_read()
1374
 
        self.add_cleanup(old_tree.unlock)
 
1446
        self.add_cleanup(old_tree.lock_read().unlock)
1375
1447
        old_inv = old_tree.inventory
1376
1448
        renames = []
1377
1449
        iterator = tree.iter_changes(old_tree, include_unchanged=True)
1396
1468
    If you want to discard your local changes, you can just do a
1397
1469
    'bzr revert' instead of 'bzr commit' after the update.
1398
1470
 
 
1471
    If you want to restore a file that has been removed locally, use
 
1472
    'bzr revert' instead of 'bzr update'.
 
1473
 
1399
1474
    If the tree's branch is bound to a master branch, it will also update
1400
1475
    the branch from the master.
1401
1476
    """
1402
1477
 
1403
1478
    _see_also = ['pull', 'working-trees', 'status-flags']
1404
1479
    takes_args = ['dir?']
1405
 
    takes_options = ['revision']
 
1480
    takes_options = ['revision',
 
1481
                     Option('show-base',
 
1482
                            help="Show base revision text in conflicts."),
 
1483
                     ]
1406
1484
    aliases = ['up']
1407
1485
 
1408
 
    def run(self, dir='.', revision=None):
 
1486
    def run(self, dir='.', revision=None, show_base=None):
1409
1487
        if revision is not None and len(revision) != 1:
1410
1488
            raise errors.BzrCommandError(
1411
1489
                        "bzr update --revision takes exactly one revision")
1415
1493
        master = branch.get_master_branch(
1416
1494
            possible_transports=possible_transports)
1417
1495
        if master is not None:
1418
 
            tree.lock_write()
1419
1496
            branch_location = master.base
 
1497
            tree.lock_write()
1420
1498
        else:
 
1499
            branch_location = tree.branch.base
1421
1500
            tree.lock_tree_write()
1422
 
            branch_location = tree.branch.base
1423
1501
        self.add_cleanup(tree.unlock)
1424
1502
        # get rid of the final '/' and be ready for display
1425
1503
        branch_location = urlutils.unescape_for_display(
1451
1529
                change_reporter,
1452
1530
                possible_transports=possible_transports,
1453
1531
                revision=revision_id,
1454
 
                old_tip=old_tip)
 
1532
                old_tip=old_tip,
 
1533
                show_base=show_base)
1455
1534
        except errors.NoSuchRevision, e:
1456
1535
            raise errors.BzrCommandError(
1457
1536
                                  "branch has no revision %s\n"
1519
1598
class cmd_remove(Command):
1520
1599
    __doc__ = """Remove files or directories.
1521
1600
 
1522
 
    This makes bzr stop tracking changes to the specified files. bzr will delete
1523
 
    them if they can easily be recovered using revert. If no options or
1524
 
    parameters are given bzr will scan for files that are being tracked by bzr
1525
 
    but missing in your tree and stop tracking them for you.
 
1601
    This makes Bazaar stop tracking changes to the specified files. Bazaar will
 
1602
    delete them if they can easily be recovered using revert otherwise they
 
1603
    will be backed up (adding an extention of the form .~#~). If no options or
 
1604
    parameters are given Bazaar will scan for files that are being tracked by
 
1605
    Bazaar but missing in your tree and stop tracking them for you.
1526
1606
    """
1527
1607
    takes_args = ['file*']
1528
1608
    takes_options = ['verbose',
1530
1610
        RegistryOption.from_kwargs('file-deletion-strategy',
1531
1611
            'The file deletion mode to be used.',
1532
1612
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1533
 
            safe='Only delete files if they can be'
1534
 
                 ' safely recovered (default).',
 
1613
            safe='Backup changed files (default).',
1535
1614
            keep='Delete from bzr but leave the working copy.',
 
1615
            no_backup='Don\'t backup changed files.',
1536
1616
            force='Delete all the specified files, even if they can not be '
1537
 
                'recovered and even if they are non-empty directories.')]
 
1617
                'recovered and even if they are non-empty directories. '
 
1618
                '(deprecated, use no-backup)')]
1538
1619
    aliases = ['rm', 'del']
1539
1620
    encoding_type = 'replace'
1540
1621
 
1541
1622
    def run(self, file_list, verbose=False, new=False,
1542
1623
        file_deletion_strategy='safe'):
1543
 
        tree, file_list = tree_files(file_list)
 
1624
        if file_deletion_strategy == 'force':
 
1625
            note("(The --force option is deprecated, rather use --no-backup "
 
1626
                "in future.)")
 
1627
            file_deletion_strategy = 'no-backup'
 
1628
 
 
1629
        tree, file_list = WorkingTree.open_containing_paths(file_list)
1544
1630
 
1545
1631
        if file_list is not None:
1546
1632
            file_list = [f for f in file_list]
1547
1633
 
1548
 
        tree.lock_write()
1549
 
        self.add_cleanup(tree.unlock)
 
1634
        self.add_cleanup(tree.lock_write().unlock)
1550
1635
        # Heuristics should probably all move into tree.remove_smart or
1551
1636
        # some such?
1552
1637
        if new:
1567
1652
            file_deletion_strategy = 'keep'
1568
1653
        tree.remove(file_list, verbose=verbose, to_file=self.outf,
1569
1654
            keep_files=file_deletion_strategy=='keep',
1570
 
            force=file_deletion_strategy=='force')
 
1655
            force=(file_deletion_strategy=='no-backup'))
1571
1656
 
1572
1657
 
1573
1658
class cmd_file_id(Command):
1635
1720
 
1636
1721
    _see_also = ['check']
1637
1722
    takes_args = ['branch?']
 
1723
    takes_options = [
 
1724
        Option('canonicalize-chks',
 
1725
               help='Make sure CHKs are in canonical form (repairs '
 
1726
                    'bug 522637).',
 
1727
               hidden=True),
 
1728
        ]
1638
1729
 
1639
 
    def run(self, branch="."):
 
1730
    def run(self, branch=".", canonicalize_chks=False):
1640
1731
        from bzrlib.reconcile import reconcile
1641
1732
        dir = bzrdir.BzrDir.open(branch)
1642
 
        reconcile(dir)
 
1733
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1643
1734
 
1644
1735
 
1645
1736
class cmd_revision_history(Command):
1677
1768
            b = wt.branch
1678
1769
            last_revision = wt.last_revision()
1679
1770
 
1680
 
        revision_ids = b.repository.get_ancestry(last_revision)
1681
 
        revision_ids.pop(0)
1682
 
        for revision_id in revision_ids:
 
1771
        self.add_cleanup(b.repository.lock_read().unlock)
 
1772
        graph = b.repository.get_graph()
 
1773
        revisions = [revid for revid, parents in
 
1774
            graph.iter_ancestry([last_revision])]
 
1775
        for revision_id in reversed(revisions):
 
1776
            if _mod_revision.is_null(revision_id):
 
1777
                continue
1683
1778
            self.outf.write(revision_id + '\n')
1684
1779
 
1685
1780
 
1722
1817
                ),
1723
1818
         Option('append-revisions-only',
1724
1819
                help='Never change revnos or the existing log.'
1725
 
                '  Append revisions to it only.')
 
1820
                '  Append revisions to it only.'),
 
1821
         Option('no-tree',
 
1822
                'Create a branch without a working tree.')
1726
1823
         ]
1727
1824
    def run(self, location=None, format=None, append_revisions_only=False,
1728
 
            create_prefix=False):
 
1825
            create_prefix=False, no_tree=False):
1729
1826
        if format is None:
1730
1827
            format = bzrdir.format_registry.make_bzrdir('default')
1731
1828
        if location is None:
1754
1851
        except errors.NotBranchError:
1755
1852
            # really a NotBzrDir error...
1756
1853
            create_branch = bzrdir.BzrDir.create_branch_convenience
 
1854
            if no_tree:
 
1855
                force_new_tree = False
 
1856
            else:
 
1857
                force_new_tree = None
1757
1858
            branch = create_branch(to_transport.base, format=format,
1758
 
                                   possible_transports=[to_transport])
 
1859
                                   possible_transports=[to_transport],
 
1860
                                   force_new_tree=force_new_tree)
1759
1861
            a_bzrdir = branch.bzrdir
1760
1862
        else:
1761
1863
            from bzrlib.transport.local import LocalTransport
1765
1867
                        raise errors.BranchExistsWithoutWorkingTree(location)
1766
1868
                raise errors.AlreadyBranchError(location)
1767
1869
            branch = a_bzrdir.create_branch()
1768
 
            a_bzrdir.create_workingtree()
 
1870
            if not no_tree:
 
1871
                a_bzrdir.create_workingtree()
1769
1872
        if append_revisions_only:
1770
1873
            try:
1771
1874
                branch.set_append_revisions_only(True)
1865
1968
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
1866
1969
    produces patches suitable for "patch -p1".
1867
1970
 
 
1971
    Note that when using the -r argument with a range of revisions, the
 
1972
    differences are computed between the two specified revisions.  That
 
1973
    is, the command does not show the changes introduced by the first 
 
1974
    revision in the range.  This differs from the interpretation of 
 
1975
    revision ranges used by "bzr log" which includes the first revision
 
1976
    in the range.
 
1977
 
1868
1978
    :Exit values:
1869
1979
        1 - changed
1870
1980
        2 - unrepresentable changes
1888
1998
 
1889
1999
            bzr diff -r1..3 xxx
1890
2000
 
1891
 
        To see the changes introduced in revision X::
 
2001
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
2002
 
 
2003
            bzr diff -c2
 
2004
 
 
2005
        To see the changes introduced by revision X::
1892
2006
        
1893
2007
            bzr diff -cX
1894
2008
 
1898
2012
 
1899
2013
            bzr diff -r<chosen_parent>..X
1900
2014
 
1901
 
        The changes introduced by revision 2 (equivalent to -r1..2)::
 
2015
        The changes between the current revision and the previous revision
 
2016
        (equivalent to -c-1 and -r-2..-1)
1902
2017
 
1903
 
            bzr diff -c2
 
2018
            bzr diff -r-2..
1904
2019
 
1905
2020
        Show just the differences for file NEWS::
1906
2021
 
1921
2036
        Same as 'bzr diff' but prefix paths with old/ and new/::
1922
2037
 
1923
2038
            bzr diff --prefix old/:new/
 
2039
            
 
2040
        Show the differences using a custom diff program with options::
 
2041
        
 
2042
            bzr diff --using /usr/bin/diff --diff-options -wu
1924
2043
    """
1925
2044
    _see_also = ['status']
1926
2045
    takes_args = ['file*']
1946
2065
            type=unicode,
1947
2066
            ),
1948
2067
        RegistryOption('format',
 
2068
            short_name='F',
1949
2069
            help='Diff format to use.',
1950
2070
            lazy_registry=('bzrlib.diff', 'format_registry'),
1951
 
            value_switches=False, title='Diff format'),
 
2071
            title='Diff format'),
1952
2072
        ]
1953
2073
    aliases = ['di', 'dif']
1954
2074
    encoding_type = 'exact'
1985
2105
         old_branch, new_branch,
1986
2106
         specific_files, extra_trees) = get_trees_and_branches_to_diff_locked(
1987
2107
            file_list, revision, old, new, self.add_cleanup, apply_view=True)
 
2108
        # GNU diff on Windows uses ANSI encoding for filenames
 
2109
        path_encoding = osutils.get_diff_header_encoding()
1988
2110
        return show_diff_trees(old_tree, new_tree, sys.stdout,
1989
2111
                               specific_files=specific_files,
1990
2112
                               external_diff_options=diff_options,
1991
2113
                               old_label=old_label, new_label=new_label,
1992
 
                               extra_trees=extra_trees, using=using,
 
2114
                               extra_trees=extra_trees,
 
2115
                               path_encoding=path_encoding,
 
2116
                               using=using,
1993
2117
                               format_cls=format)
1994
2118
 
1995
2119
 
2003
2127
    # level of effort but possibly much less IO.  (Or possibly not,
2004
2128
    # if the directories are very large...)
2005
2129
    _see_also = ['status', 'ls']
2006
 
    takes_options = ['show-ids']
 
2130
    takes_options = ['directory', 'show-ids']
2007
2131
 
2008
2132
    @display_command
2009
 
    def run(self, show_ids=False):
2010
 
        tree = WorkingTree.open_containing(u'.')[0]
2011
 
        tree.lock_read()
2012
 
        self.add_cleanup(tree.unlock)
 
2133
    def run(self, show_ids=False, directory=u'.'):
 
2134
        tree = WorkingTree.open_containing(directory)[0]
 
2135
        self.add_cleanup(tree.lock_read().unlock)
2013
2136
        old = tree.basis_tree()
2014
 
        old.lock_read()
2015
 
        self.add_cleanup(old.unlock)
 
2137
        self.add_cleanup(old.lock_read().unlock)
2016
2138
        for path, ie in old.inventory.iter_entries():
2017
2139
            if not tree.has_id(ie.file_id):
2018
2140
                self.outf.write(path)
2028
2150
 
2029
2151
    hidden = True
2030
2152
    _see_also = ['status', 'ls']
2031
 
    takes_options = [
2032
 
            Option('null',
2033
 
                   help='Write an ascii NUL (\\0) separator '
2034
 
                   'between files rather than a newline.')
2035
 
            ]
 
2153
    takes_options = ['directory', 'null']
2036
2154
 
2037
2155
    @display_command
2038
 
    def run(self, null=False):
2039
 
        tree = WorkingTree.open_containing(u'.')[0]
 
2156
    def run(self, null=False, directory=u'.'):
 
2157
        tree = WorkingTree.open_containing(directory)[0]
 
2158
        self.add_cleanup(tree.lock_read().unlock)
2040
2159
        td = tree.changes_from(tree.basis_tree())
 
2160
        self.cleanup_now()
2041
2161
        for path, id, kind, text_modified, meta_modified in td.modified:
2042
2162
            if null:
2043
2163
                self.outf.write(path + '\0')
2051
2171
 
2052
2172
    hidden = True
2053
2173
    _see_also = ['status', 'ls']
2054
 
    takes_options = [
2055
 
            Option('null',
2056
 
                   help='Write an ascii NUL (\\0) separator '
2057
 
                   'between files rather than a newline.')
2058
 
            ]
 
2174
    takes_options = ['directory', 'null']
2059
2175
 
2060
2176
    @display_command
2061
 
    def run(self, null=False):
2062
 
        wt = WorkingTree.open_containing(u'.')[0]
2063
 
        wt.lock_read()
2064
 
        self.add_cleanup(wt.unlock)
 
2177
    def run(self, null=False, directory=u'.'):
 
2178
        wt = WorkingTree.open_containing(directory)[0]
 
2179
        self.add_cleanup(wt.lock_read().unlock)
2065
2180
        basis = wt.basis_tree()
2066
 
        basis.lock_read()
2067
 
        self.add_cleanup(basis.unlock)
 
2181
        self.add_cleanup(basis.lock_read().unlock)
2068
2182
        basis_inv = basis.inventory
2069
2183
        inv = wt.inventory
2070
2184
        for file_id in inv:
2071
 
            if file_id in basis_inv:
 
2185
            if basis_inv.has_id(file_id):
2072
2186
                continue
2073
2187
            if inv.is_root(file_id) and len(basis_inv) == 0:
2074
2188
                continue
2075
2189
            path = inv.id2path(file_id)
2076
 
            if not os.access(osutils.abspath(path), os.F_OK):
 
2190
            if not os.access(osutils.pathjoin(wt.basedir, path), os.F_OK):
2077
2191
                continue
2078
2192
            if null:
2079
2193
                self.outf.write(path + '\0')
2223
2337
 
2224
2338
    :Other filtering:
2225
2339
 
2226
 
      The --message option can be used for finding revisions that match a
2227
 
      regular expression in a commit message.
 
2340
      The --match option can be used for finding revisions that match a
 
2341
      regular expression in a commit message, committer, author or bug.
 
2342
      Specifying the option several times will match any of the supplied
 
2343
      expressions. --match-author, --match-bugs, --match-committer and
 
2344
      --match-message can be used to only match a specific field.
2228
2345
 
2229
2346
    :Tips & tricks:
2230
2347
 
2279
2396
                   help='Show just the specified revision.'
2280
2397
                   ' See also "help revisionspec".'),
2281
2398
            'log-format',
 
2399
            RegistryOption('authors',
 
2400
                'What names to list as authors - first, all or committer.',
 
2401
                title='Authors',
 
2402
                lazy_registry=('bzrlib.log', 'author_list_registry'),
 
2403
            ),
2282
2404
            Option('levels',
2283
2405
                   short_name='n',
2284
2406
                   help='Number of levels to display - 0 for all, 1 for flat.',
2285
2407
                   argname='N',
2286
2408
                   type=_parse_levels),
2287
2409
            Option('message',
2288
 
                   short_name='m',
2289
2410
                   help='Show revisions whose message matches this '
2290
2411
                        'regular expression.',
2291
 
                   type=str),
 
2412
                   type=str,
 
2413
                   hidden=True),
2292
2414
            Option('limit',
2293
2415
                   short_name='l',
2294
2416
                   help='Limit the output to the first N revisions.',
2297
2419
            Option('show-diff',
2298
2420
                   short_name='p',
2299
2421
                   help='Show changes made in each revision as a patch.'),
2300
 
            Option('include-merges',
 
2422
            Option('include-merged',
2301
2423
                   help='Show merged revisions like --levels 0 does.'),
 
2424
            Option('include-merges', hidden=True,
 
2425
                   help='Historical alias for --include-merged.'),
 
2426
            Option('omit-merges',
 
2427
                   help='Do not report commits with more than one parent.'),
2302
2428
            Option('exclude-common-ancestry',
2303
2429
                   help='Display only the revisions that are not part'
2304
2430
                   ' of both ancestries (require -rX..Y)'
2305
 
                   )
 
2431
                   ),
 
2432
            Option('signatures',
 
2433
                   help='Show digital signature validity'),
 
2434
            ListOption('match',
 
2435
                short_name='m',
 
2436
                help='Show revisions whose properties match this '
 
2437
                'expression.',
 
2438
                type=str),
 
2439
            ListOption('match-message',
 
2440
                   help='Show revisions whose message matches this '
 
2441
                   'expression.',
 
2442
                type=str),
 
2443
            ListOption('match-committer',
 
2444
                   help='Show revisions whose committer matches this '
 
2445
                   'expression.',
 
2446
                type=str),
 
2447
            ListOption('match-author',
 
2448
                   help='Show revisions whose authors match this '
 
2449
                   'expression.',
 
2450
                type=str),
 
2451
            ListOption('match-bugs',
 
2452
                   help='Show revisions whose bugs match this '
 
2453
                   'expression.',
 
2454
                type=str)
2306
2455
            ]
2307
2456
    encoding_type = 'replace'
2308
2457
 
2318
2467
            message=None,
2319
2468
            limit=None,
2320
2469
            show_diff=False,
2321
 
            include_merges=False,
 
2470
            include_merged=None,
 
2471
            authors=None,
2322
2472
            exclude_common_ancestry=False,
 
2473
            signatures=False,
 
2474
            match=None,
 
2475
            match_message=None,
 
2476
            match_committer=None,
 
2477
            match_author=None,
 
2478
            match_bugs=None,
 
2479
            omit_merges=False,
 
2480
            include_merges=symbol_versioning.DEPRECATED_PARAMETER,
2323
2481
            ):
2324
2482
        from bzrlib.log import (
2325
2483
            Logger,
2327
2485
            _get_info_for_log_files,
2328
2486
            )
2329
2487
        direction = (forward and 'forward') or 'reverse'
 
2488
        if symbol_versioning.deprecated_passed(include_merges):
 
2489
            ui.ui_factory.show_user_warning(
 
2490
                'deprecated_command_option',
 
2491
                deprecated_name='--include-merges',
 
2492
                recommended_name='--include-merged',
 
2493
                deprecated_in_version='2.5',
 
2494
                command=self.invoked_as)
 
2495
            if include_merged is None:
 
2496
                include_merged = include_merges
 
2497
            else:
 
2498
                raise errors.BzrCommandError(
 
2499
                    '--include-merges and --include-merged '
 
2500
                    'are mutually exclusive')
 
2501
        if include_merged is None:
 
2502
            include_merged = False
2330
2503
        if (exclude_common_ancestry
2331
2504
            and (revision is None or len(revision) != 2)):
2332
2505
            raise errors.BzrCommandError(
2333
2506
                '--exclude-common-ancestry requires -r with two revisions')
2334
 
        if include_merges:
 
2507
        if include_merged:
2335
2508
            if levels is None:
2336
2509
                levels = 0
2337
2510
            else:
2338
2511
                raise errors.BzrCommandError(
2339
 
                    '--levels and --include-merges are mutually exclusive')
 
2512
                    '--levels and --include-merged are mutually exclusive')
2340
2513
 
2341
2514
        if change is not None:
2342
2515
            if len(change) > 1:
2352
2525
        if file_list:
2353
2526
            # find the file ids to log and check for directory filtering
2354
2527
            b, file_info_list, rev1, rev2 = _get_info_for_log_files(
2355
 
                revision, file_list)
2356
 
            self.add_cleanup(b.unlock)
 
2528
                revision, file_list, self.add_cleanup)
2357
2529
            for relpath, file_id, kind in file_info_list:
2358
2530
                if file_id is None:
2359
2531
                    raise errors.BzrCommandError(
2377
2549
                location = '.'
2378
2550
            dir, relpath = bzrdir.BzrDir.open_containing(location)
2379
2551
            b = dir.open_branch()
2380
 
            b.lock_read()
2381
 
            self.add_cleanup(b.unlock)
 
2552
            self.add_cleanup(b.lock_read().unlock)
2382
2553
            rev1, rev2 = _get_revision_range(revision, b, self.name())
2383
2554
 
 
2555
        if b.get_config().validate_signatures_in_log():
 
2556
            signatures = True
 
2557
 
 
2558
        if signatures:
 
2559
            if not gpg.GPGStrategy.verify_signatures_available():
 
2560
                raise errors.GpgmeNotInstalled(None)
 
2561
 
2384
2562
        # Decide on the type of delta & diff filtering to use
2385
2563
        # TODO: add an --all-files option to make this configurable & consistent
2386
2564
        if not verbose:
2404
2582
                        show_timezone=timezone,
2405
2583
                        delta_format=get_verbosity_level(),
2406
2584
                        levels=levels,
2407
 
                        show_advice=levels is None)
 
2585
                        show_advice=levels is None,
 
2586
                        author_list_handler=authors)
2408
2587
 
2409
2588
        # Choose the algorithm for doing the logging. It's annoying
2410
2589
        # having multiple code paths like this but necessary until
2422
2601
        match_using_deltas = (len(file_ids) != 1 or filter_by_dir
2423
2602
            or delta_type or partial_history)
2424
2603
 
 
2604
        match_dict = {}
 
2605
        if match:
 
2606
            match_dict[''] = match
 
2607
        if match_message:
 
2608
            match_dict['message'] = match_message
 
2609
        if match_committer:
 
2610
            match_dict['committer'] = match_committer
 
2611
        if match_author:
 
2612
            match_dict['author'] = match_author
 
2613
        if match_bugs:
 
2614
            match_dict['bugs'] = match_bugs
 
2615
            
2425
2616
        # Build the LogRequest and execute it
2426
2617
        if len(file_ids) == 0:
2427
2618
            file_ids = None
2430
2621
            start_revision=rev1, end_revision=rev2, limit=limit,
2431
2622
            message_search=message, delta_type=delta_type,
2432
2623
            diff_type=diff_type, _match_using_deltas=match_using_deltas,
2433
 
            exclude_common_ancestry=exclude_common_ancestry,
 
2624
            exclude_common_ancestry=exclude_common_ancestry, match=match_dict,
 
2625
            signature=signatures, omit_merges=omit_merges,
2434
2626
            )
2435
2627
        Logger(b, rqst).show(lf)
2436
2628
 
2508
2700
        tree, relpath = WorkingTree.open_containing(filename)
2509
2701
        file_id = tree.path2id(relpath)
2510
2702
        b = tree.branch
2511
 
        b.lock_read()
2512
 
        self.add_cleanup(b.unlock)
 
2703
        self.add_cleanup(b.lock_read().unlock)
2513
2704
        touching_revs = log.find_touching_revisions(b, file_id)
2514
2705
        for revno, revision_id, what in touching_revs:
2515
2706
            self.outf.write("%6d %s\n" % (revno, what))
2528
2719
                   help='Recurse into subdirectories.'),
2529
2720
            Option('from-root',
2530
2721
                   help='Print paths relative to the root of the branch.'),
2531
 
            Option('unknown', help='Print unknown files.'),
 
2722
            Option('unknown', short_name='u',
 
2723
                help='Print unknown files.'),
2532
2724
            Option('versioned', help='Print versioned files.',
2533
2725
                   short_name='V'),
2534
 
            Option('ignored', help='Print ignored files.'),
2535
 
            Option('null',
2536
 
                   help='Write an ascii NUL (\\0) separator '
2537
 
                   'between files rather than a newline.'),
2538
 
            Option('kind',
 
2726
            Option('ignored', short_name='i',
 
2727
                help='Print ignored files.'),
 
2728
            Option('kind', short_name='k',
2539
2729
                   help='List entries of a particular kind: file, directory, symlink.',
2540
2730
                   type=unicode),
 
2731
            'null',
2541
2732
            'show-ids',
 
2733
            'directory',
2542
2734
            ]
2543
2735
    @display_command
2544
2736
    def run(self, revision=None, verbose=False,
2545
2737
            recursive=False, from_root=False,
2546
2738
            unknown=False, versioned=False, ignored=False,
2547
 
            null=False, kind=None, show_ids=False, path=None):
 
2739
            null=False, kind=None, show_ids=False, path=None, directory=None):
2548
2740
 
2549
2741
        if kind and kind not in ('file', 'directory', 'symlink'):
2550
2742
            raise errors.BzrCommandError('invalid kind specified')
2562
2754
                raise errors.BzrCommandError('cannot specify both --from-root'
2563
2755
                                             ' and PATH')
2564
2756
            fs_path = path
2565
 
        tree, branch, relpath = bzrdir.BzrDir.open_containing_tree_or_branch(
2566
 
            fs_path)
 
2757
        tree, branch, relpath = \
 
2758
            _open_directory_or_containing_tree_or_branch(fs_path, directory)
2567
2759
 
2568
2760
        # Calculate the prefix to use
2569
2761
        prefix = None
2584
2776
                view_str = views.view_display_str(view_files)
2585
2777
                note("Ignoring files outside view. View is %s" % view_str)
2586
2778
 
2587
 
        tree.lock_read()
2588
 
        self.add_cleanup(tree.unlock)
 
2779
        self.add_cleanup(tree.lock_read().unlock)
2589
2780
        for fp, fc, fkind, fid, entry in tree.list_files(include_root=False,
2590
2781
            from_dir=relpath, recursive=recursive):
2591
2782
            # Apply additional masking
2638
2829
 
2639
2830
    hidden = True
2640
2831
    _see_also = ['ls']
 
2832
    takes_options = ['directory']
2641
2833
 
2642
2834
    @display_command
2643
 
    def run(self):
2644
 
        for f in WorkingTree.open_containing(u'.')[0].unknowns():
 
2835
    def run(self, directory=u'.'):
 
2836
        for f in WorkingTree.open_containing(directory)[0].unknowns():
2645
2837
            self.outf.write(osutils.quotefn(f) + '\n')
2646
2838
 
2647
2839
 
2674
2866
    Patterns prefixed with '!!' act as regular ignore patterns, but have
2675
2867
    precedence over the '!' exception patterns.
2676
2868
 
2677
 
    Note: ignore patterns containing shell wildcards must be quoted from
2678
 
    the shell on Unix.
 
2869
    :Notes: 
 
2870
        
 
2871
    * Ignore patterns containing shell wildcards must be quoted from
 
2872
      the shell on Unix.
 
2873
 
 
2874
    * Ignore patterns starting with "#" act as comments in the ignore file.
 
2875
      To ignore patterns that begin with that character, use the "RE:" prefix.
2679
2876
 
2680
2877
    :Examples:
2681
2878
        Ignore the top level Makefile::
2690
2887
 
2691
2888
            bzr ignore "!special.class"
2692
2889
 
 
2890
        Ignore files whose name begins with the "#" character::
 
2891
 
 
2892
            bzr ignore "RE:^#"
 
2893
 
2693
2894
        Ignore .o files under the lib directory::
2694
2895
 
2695
2896
            bzr ignore "lib/**/*.o"
2703
2904
            bzr ignore "RE:(?!debian/).*"
2704
2905
        
2705
2906
        Ignore everything except the "local" toplevel directory,
2706
 
        but always ignore "*~" autosave files, even under local/::
 
2907
        but always ignore autosave files ending in ~, even under local/::
2707
2908
        
2708
2909
            bzr ignore "*"
2709
2910
            bzr ignore "!./local"
2712
2913
 
2713
2914
    _see_also = ['status', 'ignored', 'patterns']
2714
2915
    takes_args = ['name_pattern*']
2715
 
    takes_options = [
 
2916
    takes_options = ['directory',
2716
2917
        Option('default-rules',
2717
2918
               help='Display the default ignore rules that bzr uses.')
2718
2919
        ]
2719
2920
 
2720
 
    def run(self, name_pattern_list=None, default_rules=None):
 
2921
    def run(self, name_pattern_list=None, default_rules=None,
 
2922
            directory=u'.'):
2721
2923
        from bzrlib import ignores
2722
2924
        if default_rules is not None:
2723
2925
            # dump the default rules and exit
2729
2931
                "NAME_PATTERN or --default-rules.")
2730
2932
        name_pattern_list = [globbing.normalize_pattern(p)
2731
2933
                             for p in name_pattern_list]
 
2934
        bad_patterns = ''
 
2935
        for p in name_pattern_list:
 
2936
            if not globbing.Globster.is_pattern_valid(p):
 
2937
                bad_patterns += ('\n  %s' % p)
 
2938
        if bad_patterns:
 
2939
            msg = ('Invalid ignore pattern(s) found. %s' % bad_patterns)
 
2940
            ui.ui_factory.show_error(msg)
 
2941
            raise errors.InvalidPattern('')
2732
2942
        for name_pattern in name_pattern_list:
2733
2943
            if (name_pattern[0] == '/' or
2734
2944
                (len(name_pattern) > 1 and name_pattern[1] == ':')):
2735
2945
                raise errors.BzrCommandError(
2736
2946
                    "NAME_PATTERN should not be an absolute path")
2737
 
        tree, relpath = WorkingTree.open_containing(u'.')
 
2947
        tree, relpath = WorkingTree.open_containing(directory)
2738
2948
        ignores.tree_ignores_add_patterns(tree, name_pattern_list)
2739
2949
        ignored = globbing.Globster(name_pattern_list)
2740
2950
        matches = []
2741
 
        tree.lock_read()
 
2951
        self.add_cleanup(tree.lock_read().unlock)
2742
2952
        for entry in tree.list_files():
2743
2953
            id = entry[3]
2744
2954
            if id is not None:
2745
2955
                filename = entry[0]
2746
2956
                if ignored.match(filename):
2747
2957
                    matches.append(filename)
2748
 
        tree.unlock()
2749
2958
        if len(matches) > 0:
2750
2959
            self.outf.write("Warning: the following files are version controlled and"
2751
2960
                  " match your ignore pattern:\n%s"
2766
2975
 
2767
2976
    encoding_type = 'replace'
2768
2977
    _see_also = ['ignore', 'ls']
 
2978
    takes_options = ['directory']
2769
2979
 
2770
2980
    @display_command
2771
 
    def run(self):
2772
 
        tree = WorkingTree.open_containing(u'.')[0]
2773
 
        tree.lock_read()
2774
 
        self.add_cleanup(tree.unlock)
 
2981
    def run(self, directory=u'.'):
 
2982
        tree = WorkingTree.open_containing(directory)[0]
 
2983
        self.add_cleanup(tree.lock_read().unlock)
2775
2984
        for path, file_class, kind, file_id, entry in tree.list_files():
2776
2985
            if file_class != 'I':
2777
2986
                continue
2788
2997
    """
2789
2998
    hidden = True
2790
2999
    takes_args = ['revno']
 
3000
    takes_options = ['directory']
2791
3001
 
2792
3002
    @display_command
2793
 
    def run(self, revno):
 
3003
    def run(self, revno, directory=u'.'):
2794
3004
        try:
2795
3005
            revno = int(revno)
2796
3006
        except ValueError:
2797
3007
            raise errors.BzrCommandError("not a valid revision-number: %r"
2798
3008
                                         % revno)
2799
 
        revid = WorkingTree.open_containing(u'.')[0].branch.get_rev_id(revno)
 
3009
        revid = WorkingTree.open_containing(directory)[0].branch.get_rev_id(revno)
2800
3010
        self.outf.write("%s\n" % revid)
2801
3011
 
2802
3012
 
2828
3038
         zip                          .zip
2829
3039
      =================       =========================
2830
3040
    """
 
3041
    encoding = 'exact'
2831
3042
    takes_args = ['dest', 'branch_or_subdir?']
2832
 
    takes_options = [
 
3043
    takes_options = ['directory',
2833
3044
        Option('format',
2834
3045
               help="Type of file to export to.",
2835
3046
               type=unicode),
2844
3055
                    'revision in which it was changed.'),
2845
3056
        ]
2846
3057
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
2847
 
        root=None, filters=False, per_file_timestamps=False):
 
3058
        root=None, filters=False, per_file_timestamps=False, directory=u'.'):
2848
3059
        from bzrlib.export import export
2849
3060
 
2850
3061
        if branch_or_subdir is None:
2851
 
            tree = WorkingTree.open_containing(u'.')[0]
 
3062
            tree = WorkingTree.open_containing(directory)[0]
2852
3063
            b = tree.branch
2853
3064
            subdir = None
2854
3065
        else:
2873
3084
    """
2874
3085
 
2875
3086
    _see_also = ['ls']
2876
 
    takes_options = [
 
3087
    takes_options = ['directory',
2877
3088
        Option('name-from-revision', help='The path name in the old tree.'),
2878
3089
        Option('filters', help='Apply content filters to display the '
2879
3090
                'convenience form.'),
2884
3095
 
2885
3096
    @display_command
2886
3097
    def run(self, filename, revision=None, name_from_revision=False,
2887
 
            filters=False):
 
3098
            filters=False, directory=None):
2888
3099
        if revision is not None and len(revision) != 1:
2889
3100
            raise errors.BzrCommandError("bzr cat --revision takes exactly"
2890
3101
                                         " one revision specifier")
2891
3102
        tree, branch, relpath = \
2892
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
2893
 
        branch.lock_read()
2894
 
        self.add_cleanup(branch.unlock)
 
3103
            _open_directory_or_containing_tree_or_branch(filename, directory)
 
3104
        self.add_cleanup(branch.lock_read().unlock)
2895
3105
        return self._run(tree, branch, relpath, filename, revision,
2896
3106
                         name_from_revision, filters)
2897
3107
 
2900
3110
        if tree is None:
2901
3111
            tree = b.basis_tree()
2902
3112
        rev_tree = _get_one_revision_tree('cat', revision, branch=b)
2903
 
        rev_tree.lock_read()
2904
 
        self.add_cleanup(rev_tree.unlock)
 
3113
        self.add_cleanup(rev_tree.lock_read().unlock)
2905
3114
 
2906
3115
        old_file_id = rev_tree.path2id(relpath)
2907
3116
 
 
3117
        # TODO: Split out this code to something that generically finds the
 
3118
        # best id for a path across one or more trees; it's like
 
3119
        # find_ids_across_trees but restricted to find just one. -- mbp
 
3120
        # 20110705.
2908
3121
        if name_from_revision:
2909
3122
            # Try in revision if requested
2910
3123
            if old_file_id is None:
2912
3125
                    "%r is not present in revision %s" % (
2913
3126
                        filename, rev_tree.get_revision_id()))
2914
3127
            else:
2915
 
                content = rev_tree.get_file_text(old_file_id)
 
3128
                actual_file_id = old_file_id
2916
3129
        else:
2917
3130
            cur_file_id = tree.path2id(relpath)
2918
 
            found = False
2919
 
            if cur_file_id is not None:
2920
 
                # Then try with the actual file id
2921
 
                try:
2922
 
                    content = rev_tree.get_file_text(cur_file_id)
2923
 
                    found = True
2924
 
                except errors.NoSuchId:
2925
 
                    # The actual file id didn't exist at that time
2926
 
                    pass
2927
 
            if not found and old_file_id is not None:
2928
 
                # Finally try with the old file id
2929
 
                content = rev_tree.get_file_text(old_file_id)
2930
 
                found = True
2931
 
            if not found:
2932
 
                # Can't be found anywhere
 
3131
            if cur_file_id is not None and rev_tree.has_id(cur_file_id):
 
3132
                actual_file_id = cur_file_id
 
3133
            elif old_file_id is not None:
 
3134
                actual_file_id = old_file_id
 
3135
            else:
2933
3136
                raise errors.BzrCommandError(
2934
3137
                    "%r is not present in revision %s" % (
2935
3138
                        filename, rev_tree.get_revision_id()))
2936
3139
        if filtered:
2937
 
            from bzrlib.filters import (
2938
 
                ContentFilterContext,
2939
 
                filtered_output_bytes,
2940
 
                )
2941
 
            filters = rev_tree._content_filter_stack(relpath)
2942
 
            chunks = content.splitlines(True)
2943
 
            content = filtered_output_bytes(chunks, filters,
2944
 
                ContentFilterContext(relpath, rev_tree))
2945
 
            self.cleanup_now()
2946
 
            self.outf.writelines(content)
 
3140
            from bzrlib.filter_tree import ContentFilterTree
 
3141
            filter_tree = ContentFilterTree(rev_tree,
 
3142
                rev_tree._content_filter_stack)
 
3143
            content = filter_tree.get_file_text(actual_file_id)
2947
3144
        else:
2948
 
            self.cleanup_now()
2949
 
            self.outf.write(content)
 
3145
            content = rev_tree.get_file_text(actual_file_id)
 
3146
        self.cleanup_now()
 
3147
        self.outf.write(content)
2950
3148
 
2951
3149
 
2952
3150
class cmd_local_time_offset(Command):
3013
3211
      to trigger updates to external systems like bug trackers. The --fixes
3014
3212
      option can be used to record the association between a revision and
3015
3213
      one or more bugs. See ``bzr help bugs`` for details.
3016
 
 
3017
 
      A selective commit may fail in some cases where the committed
3018
 
      tree would be invalid. Consider::
3019
 
  
3020
 
        bzr init foo
3021
 
        mkdir foo/bar
3022
 
        bzr add foo/bar
3023
 
        bzr commit foo -m "committing foo"
3024
 
        bzr mv foo/bar foo/baz
3025
 
        mkdir foo/bar
3026
 
        bzr add foo/bar
3027
 
        bzr commit foo/bar -m "committing bar but not baz"
3028
 
  
3029
 
      In the example above, the last commit will fail by design. This gives
3030
 
      the user the opportunity to decide whether they want to commit the
3031
 
      rename at the same time, separately first, or not at all. (As a general
3032
 
      rule, when in doubt, Bazaar has a policy of Doing the Safe Thing.)
3033
3214
    """
3034
 
    # TODO: Run hooks on tree to-be-committed, and after commit.
3035
 
 
3036
 
    # TODO: Strict commit that fails if there are deleted files.
3037
 
    #       (what does "deleted files" mean ??)
3038
 
 
3039
 
    # TODO: Give better message for -s, --summary, used by tla people
3040
 
 
3041
 
    # XXX: verbose currently does nothing
3042
3215
 
3043
3216
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3044
3217
    takes_args = ['selected*']
3076
3249
             Option('show-diff', short_name='p',
3077
3250
                    help='When no message is supplied, show the diff along'
3078
3251
                    ' with the status summary in the message editor.'),
 
3252
             Option('lossy', 
 
3253
                    help='When committing to a foreign version control '
 
3254
                    'system do not push data that can not be natively '
 
3255
                    'represented.'),
3079
3256
             ]
3080
3257
    aliases = ['ci', 'checkin']
3081
3258
 
3082
3259
    def _iter_bug_fix_urls(self, fixes, branch):
 
3260
        default_bugtracker  = None
3083
3261
        # Configure the properties for bug fixing attributes.
3084
3262
        for fixed_bug in fixes:
3085
3263
            tokens = fixed_bug.split(':')
3086
 
            if len(tokens) != 2:
 
3264
            if len(tokens) == 1:
 
3265
                if default_bugtracker is None:
 
3266
                    branch_config = branch.get_config()
 
3267
                    default_bugtracker = branch_config.get_user_option(
 
3268
                        "bugtracker")
 
3269
                if default_bugtracker is None:
 
3270
                    raise errors.BzrCommandError(
 
3271
                        "No tracker specified for bug %s. Use the form "
 
3272
                        "'tracker:id' or specify a default bug tracker "
 
3273
                        "using the `bugtracker` option.\nSee "
 
3274
                        "\"bzr help bugs\" for more information on this "
 
3275
                        "feature. Commit refused." % fixed_bug)
 
3276
                tag = default_bugtracker
 
3277
                bug_id = tokens[0]
 
3278
            elif len(tokens) != 2:
3087
3279
                raise errors.BzrCommandError(
3088
3280
                    "Invalid bug %s. Must be in the form of 'tracker:id'. "
3089
3281
                    "See \"bzr help bugs\" for more information on this "
3090
3282
                    "feature.\nCommit refused." % fixed_bug)
3091
 
            tag, bug_id = tokens
 
3283
            else:
 
3284
                tag, bug_id = tokens
3092
3285
            try:
3093
3286
                yield bugtracker.get_bug_url(tag, branch, bug_id)
3094
3287
            except errors.UnknownBugTrackerAbbreviation:
3100
3293
 
3101
3294
    def run(self, message=None, file=None, verbose=False, selected_list=None,
3102
3295
            unchanged=False, strict=False, local=False, fixes=None,
3103
 
            author=None, show_diff=False, exclude=None, commit_time=None):
 
3296
            author=None, show_diff=False, exclude=None, commit_time=None,
 
3297
            lossy=False):
3104
3298
        from bzrlib.errors import (
3105
3299
            PointlessCommit,
3106
3300
            ConflictsInTree,
3109
3303
        from bzrlib.msgeditor import (
3110
3304
            edit_commit_message_encoded,
3111
3305
            generate_commit_message_template,
3112
 
            make_commit_message_template_encoded
 
3306
            make_commit_message_template_encoded,
 
3307
            set_commit_message,
3113
3308
        )
3114
3309
 
3115
3310
        commit_stamp = offset = None
3120
3315
                raise errors.BzrCommandError(
3121
3316
                    "Could not parse --commit-time: " + str(e))
3122
3317
 
3123
 
        # TODO: Need a blackbox test for invoking the external editor; may be
3124
 
        # slightly problematic to run this cross-platform.
3125
 
 
3126
 
        # TODO: do more checks that the commit will succeed before
3127
 
        # spending the user's valuable time typing a commit message.
3128
 
 
3129
3318
        properties = {}
3130
3319
 
3131
 
        tree, selected_list = tree_files(selected_list)
 
3320
        tree, selected_list = WorkingTree.open_containing_paths(selected_list)
3132
3321
        if selected_list == ['']:
3133
3322
            # workaround - commit of root of tree should be exactly the same
3134
3323
            # as just default commit in that tree, and succeed even though
3169
3358
        def get_message(commit_obj):
3170
3359
            """Callback to get commit message"""
3171
3360
            if file:
3172
 
                my_message = codecs.open(
3173
 
                    file, 'rt', osutils.get_user_encoding()).read()
 
3361
                f = open(file)
 
3362
                try:
 
3363
                    my_message = f.read().decode(osutils.get_user_encoding())
 
3364
                finally:
 
3365
                    f.close()
3174
3366
            elif message is not None:
3175
3367
                my_message = message
3176
3368
            else:
3184
3376
                # make_commit_message_template_encoded returns user encoding.
3185
3377
                # We probably want to be using edit_commit_message instead to
3186
3378
                # avoid this.
3187
 
                start_message = generate_commit_message_template(commit_obj)
3188
 
                my_message = edit_commit_message_encoded(text,
3189
 
                    start_message=start_message)
 
3379
                my_message = set_commit_message(commit_obj)
 
3380
                if my_message is None:
 
3381
                    start_message = generate_commit_message_template(commit_obj)
 
3382
                    my_message = edit_commit_message_encoded(text,
 
3383
                        start_message=start_message)
3190
3384
                if my_message is None:
3191
3385
                    raise errors.BzrCommandError("please specify a commit"
3192
3386
                        " message with either --message or --file")
3193
 
            if my_message == "":
3194
 
                raise errors.BzrCommandError("empty commit message specified")
 
3387
                if my_message == "":
 
3388
                    raise errors.BzrCommandError("Empty commit message specified."
 
3389
                            " Please specify a commit message with either"
 
3390
                            " --message or --file or leave a blank message"
 
3391
                            " with --message \"\".")
3195
3392
            return my_message
3196
3393
 
3197
3394
        # The API permits a commit with a filter of [] to mean 'select nothing'
3205
3402
                        reporter=None, verbose=verbose, revprops=properties,
3206
3403
                        authors=author, timestamp=commit_stamp,
3207
3404
                        timezone=offset,
3208
 
                        exclude=safe_relpath_files(tree, exclude))
 
3405
                        exclude=tree.safe_relpath_files(exclude),
 
3406
                        lossy=lossy)
3209
3407
        except PointlessCommit:
3210
3408
            raise errors.BzrCommandError("No changes to commit."
3211
 
                              " Use --unchanged to commit anyhow.")
 
3409
                " Please 'bzr add' the files you want to commit, or use"
 
3410
                " --unchanged to force an empty commit.")
3212
3411
        except ConflictsInTree:
3213
3412
            raise errors.BzrCommandError('Conflicts detected in working '
3214
3413
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
3295
3494
 
3296
3495
 
3297
3496
class cmd_upgrade(Command):
3298
 
    __doc__ = """Upgrade branch storage to current format.
3299
 
 
3300
 
    The check command or bzr developers may sometimes advise you to run
3301
 
    this command. When the default format has changed you may also be warned
3302
 
    during other operations to upgrade.
 
3497
    __doc__ = """Upgrade a repository, branch or working tree to a newer format.
 
3498
 
 
3499
    When the default format has changed after a major new release of
 
3500
    Bazaar, you may be informed during certain operations that you
 
3501
    should upgrade. Upgrading to a newer format may improve performance
 
3502
    or make new features available. It may however limit interoperability
 
3503
    with older repositories or with older versions of Bazaar.
 
3504
 
 
3505
    If you wish to upgrade to a particular format rather than the
 
3506
    current default, that can be specified using the --format option.
 
3507
    As a consequence, you can use the upgrade command this way to
 
3508
    "downgrade" to an earlier format, though some conversions are
 
3509
    a one way process (e.g. changing from the 1.x default to the
 
3510
    2.x default) so downgrading is not always possible.
 
3511
 
 
3512
    A backup.bzr.~#~ directory is created at the start of the conversion
 
3513
    process (where # is a number). By default, this is left there on
 
3514
    completion. If the conversion fails, delete the new .bzr directory
 
3515
    and rename this one back in its place. Use the --clean option to ask
 
3516
    for the backup.bzr directory to be removed on successful conversion.
 
3517
    Alternatively, you can delete it by hand if everything looks good
 
3518
    afterwards.
 
3519
 
 
3520
    If the location given is a shared repository, dependent branches
 
3521
    are also converted provided the repository converts successfully.
 
3522
    If the conversion of a branch fails, remaining branches are still
 
3523
    tried.
 
3524
 
 
3525
    For more information on upgrades, see the Bazaar Upgrade Guide,
 
3526
    http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.
3303
3527
    """
3304
3528
 
3305
 
    _see_also = ['check']
 
3529
    _see_also = ['check', 'reconcile', 'formats']
3306
3530
    takes_args = ['url?']
3307
3531
    takes_options = [
3308
 
                    RegistryOption('format',
3309
 
                        help='Upgrade to a specific format.  See "bzr help'
3310
 
                             ' formats" for details.',
3311
 
                        lazy_registry=('bzrlib.bzrdir', 'format_registry'),
3312
 
                        converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
3313
 
                        value_switches=True, title='Branch format'),
3314
 
                    ]
 
3532
        RegistryOption('format',
 
3533
            help='Upgrade to a specific format.  See "bzr help'
 
3534
                 ' formats" for details.',
 
3535
            lazy_registry=('bzrlib.bzrdir', 'format_registry'),
 
3536
            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),
 
3537
            value_switches=True, title='Branch format'),
 
3538
        Option('clean',
 
3539
            help='Remove the backup.bzr directory if successful.'),
 
3540
        Option('dry-run',
 
3541
            help="Show what would be done, but don't actually do anything."),
 
3542
    ]
3315
3543
 
3316
 
    def run(self, url='.', format=None):
 
3544
    def run(self, url='.', format=None, clean=False, dry_run=False):
3317
3545
        from bzrlib.upgrade import upgrade
3318
 
        upgrade(url, format)
 
3546
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
 
3547
        if exceptions:
 
3548
            if len(exceptions) == 1:
 
3549
                # Compatibility with historical behavior
 
3550
                raise exceptions[0]
 
3551
            else:
 
3552
                return 3
3319
3553
 
3320
3554
 
3321
3555
class cmd_whoami(Command):
3330
3564
 
3331
3565
            bzr whoami "Frank Chu <fchu@example.com>"
3332
3566
    """
3333
 
    takes_options = [ Option('email',
 
3567
    takes_options = [ 'directory',
 
3568
                      Option('email',
3334
3569
                             help='Display email address only.'),
3335
3570
                      Option('branch',
3336
3571
                             help='Set identity for the current branch instead of '
3340
3575
    encoding_type = 'replace'
3341
3576
 
3342
3577
    @display_command
3343
 
    def run(self, email=False, branch=False, name=None):
 
3578
    def run(self, email=False, branch=False, name=None, directory=None):
3344
3579
        if name is None:
3345
 
            # use branch if we're inside one; otherwise global config
3346
 
            try:
3347
 
                c = Branch.open_containing('.')[0].get_config()
3348
 
            except errors.NotBranchError:
3349
 
                c = config.GlobalConfig()
 
3580
            if directory is None:
 
3581
                # use branch if we're inside one; otherwise global config
 
3582
                try:
 
3583
                    c = Branch.open_containing(u'.')[0].get_config()
 
3584
                except errors.NotBranchError:
 
3585
                    c = _mod_config.GlobalConfig()
 
3586
            else:
 
3587
                c = Branch.open(directory).get_config()
3350
3588
            if email:
3351
3589
                self.outf.write(c.user_email() + '\n')
3352
3590
            else:
3353
3591
                self.outf.write(c.username() + '\n')
3354
3592
            return
3355
3593
 
 
3594
        if email:
 
3595
            raise errors.BzrCommandError("--email can only be used to display existing "
 
3596
                                         "identity")
 
3597
 
3356
3598
        # display a warning if an email address isn't included in the given name.
3357
3599
        try:
3358
 
            config.extract_email_address(name)
 
3600
            _mod_config.extract_email_address(name)
3359
3601
        except errors.NoEmailInUsername, e:
3360
3602
            warning('"%s" does not seem to contain an email address.  '
3361
3603
                    'This is allowed, but not recommended.', name)
3362
3604
 
3363
3605
        # use global config unless --branch given
3364
3606
        if branch:
3365
 
            c = Branch.open_containing('.')[0].get_config()
 
3607
            if directory is None:
 
3608
                c = Branch.open_containing(u'.')[0].get_config()
 
3609
            else:
 
3610
                c = Branch.open(directory).get_config()
3366
3611
        else:
3367
 
            c = config.GlobalConfig()
 
3612
            c = _mod_config.GlobalConfig()
3368
3613
        c.set_user_option('email', name)
3369
3614
 
3370
3615
 
3380
3625
 
3381
3626
    _see_also = ['info']
3382
3627
    takes_args = ['nickname?']
3383
 
    def run(self, nickname=None):
3384
 
        branch = Branch.open_containing(u'.')[0]
 
3628
    takes_options = ['directory']
 
3629
    def run(self, nickname=None, directory=u'.'):
 
3630
        branch = Branch.open_containing(directory)[0]
3385
3631
        if nickname is None:
3386
3632
            self.printme(branch)
3387
3633
        else:
3436
3682
                'bzr alias --remove expects an alias to remove.')
3437
3683
        # If alias is not found, print something like:
3438
3684
        # unalias: foo: not found
3439
 
        c = config.GlobalConfig()
 
3685
        c = _mod_config.GlobalConfig()
3440
3686
        c.unset_alias(alias_name)
3441
3687
 
3442
3688
    @display_command
3443
3689
    def print_aliases(self):
3444
3690
        """Print out the defined aliases in a similar format to bash."""
3445
 
        aliases = config.GlobalConfig().get_aliases()
 
3691
        aliases = _mod_config.GlobalConfig().get_aliases()
3446
3692
        for key, value in sorted(aliases.iteritems()):
3447
3693
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
3448
3694
 
3458
3704
 
3459
3705
    def set_alias(self, alias_name, alias_command):
3460
3706
        """Save the alias in the global config."""
3461
 
        c = config.GlobalConfig()
 
3707
        c = _mod_config.GlobalConfig()
3462
3708
        c.set_alias(alias_name, alias_command)
3463
3709
 
3464
3710
 
3499
3745
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
3500
3746
    into a pdb postmortem session.
3501
3747
 
 
3748
    The --coverage=DIRNAME global option produces a report with covered code
 
3749
    indicated.
 
3750
 
3502
3751
    :Examples:
3503
3752
        Run only tests relating to 'ignore'::
3504
3753
 
3515
3764
        if typestring == "sftp":
3516
3765
            from bzrlib.tests import stub_sftp
3517
3766
            return stub_sftp.SFTPAbsoluteServer
3518
 
        if typestring == "memory":
 
3767
        elif typestring == "memory":
3519
3768
            from bzrlib.tests import test_server
3520
3769
            return memory.MemoryServer
3521
 
        if typestring == "fakenfs":
 
3770
        elif typestring == "fakenfs":
3522
3771
            from bzrlib.tests import test_server
3523
3772
            return test_server.FakeNFSServer
3524
3773
        msg = "No known transport type %s. Supported types are: sftp\n" %\
3537
3786
                                 'throughout the test suite.',
3538
3787
                            type=get_transport_type),
3539
3788
                     Option('benchmark',
3540
 
                            help='Run the benchmarks rather than selftests.'),
 
3789
                            help='Run the benchmarks rather than selftests.',
 
3790
                            hidden=True),
3541
3791
                     Option('lsprof-timed',
3542
3792
                            help='Generate lsprof output for benchmarked'
3543
3793
                                 ' sections of code.'),
3544
3794
                     Option('lsprof-tests',
3545
3795
                            help='Generate lsprof output for each test.'),
3546
 
                     Option('cache-dir', type=str,
3547
 
                            help='Cache intermediate benchmark output in this '
3548
 
                                 'directory.'),
3549
3796
                     Option('first',
3550
3797
                            help='Run all tests, but run specified tests first.',
3551
3798
                            short_name='f',
3560
3807
                     Option('randomize', type=str, argname="SEED",
3561
3808
                            help='Randomize the order of tests using the given'
3562
3809
                                 ' seed or "now" for the current time.'),
3563
 
                     Option('exclude', type=str, argname="PATTERN",
3564
 
                            short_name='x',
3565
 
                            help='Exclude tests that match this regular'
3566
 
                                 ' expression.'),
 
3810
                     ListOption('exclude', type=str, argname="PATTERN",
 
3811
                                short_name='x',
 
3812
                                help='Exclude tests that match this regular'
 
3813
                                ' expression.'),
3567
3814
                     Option('subunit',
3568
3815
                        help='Output test progress via subunit.'),
3569
3816
                     Option('strict', help='Fail on missing dependencies or '
3576
3823
                                param_name='starting_with', short_name='s',
3577
3824
                                help=
3578
3825
                                'Load only the tests starting with TESTID.'),
 
3826
                     Option('sync',
 
3827
                            help="By default we disable fsync and fdatasync"
 
3828
                                 " while running the test suite.")
3579
3829
                     ]
3580
3830
    encoding_type = 'replace'
3581
3831
 
3585
3835
 
3586
3836
    def run(self, testspecs_list=None, verbose=False, one=False,
3587
3837
            transport=None, benchmark=None,
3588
 
            lsprof_timed=None, cache_dir=None,
 
3838
            lsprof_timed=None,
3589
3839
            first=False, list_only=False,
3590
3840
            randomize=None, exclude=None, strict=False,
3591
3841
            load_list=None, debugflag=None, starting_with=None, subunit=False,
3592
 
            parallel=None, lsprof_tests=False):
3593
 
        from bzrlib.tests import selftest
3594
 
        import bzrlib.benchmarks as benchmarks
3595
 
        from bzrlib.benchmarks import tree_creator
3596
 
 
3597
 
        # Make deprecation warnings visible, unless -Werror is set
3598
 
        symbol_versioning.activate_deprecation_warnings(override=False)
3599
 
 
3600
 
        if cache_dir is not None:
3601
 
            tree_creator.TreeCreator.CACHE_ROOT = osutils.abspath(cache_dir)
 
3842
            parallel=None, lsprof_tests=False,
 
3843
            sync=False):
 
3844
        from bzrlib import tests
 
3845
 
3602
3846
        if testspecs_list is not None:
3603
3847
            pattern = '|'.join(testspecs_list)
3604
3848
        else:
3612
3856
            self.additional_selftest_args['runner_class'] = SubUnitBzrRunner
3613
3857
            # On Windows, disable automatic conversion of '\n' to '\r\n' in
3614
3858
            # stdout, which would corrupt the subunit stream. 
3615
 
            if sys.platform == "win32" and sys.stdout.fileno() >= 0:
 
3859
            # FIXME: This has been fixed in subunit trunk (>0.0.5) so the
 
3860
            # following code can be deleted when it's sufficiently deployed
 
3861
            # -- vila/mgz 20100514
 
3862
            if (sys.platform == "win32"
 
3863
                and getattr(sys.stdout, 'fileno', None) is not None):
3616
3864
                import msvcrt
3617
3865
                msvcrt.setmode(sys.stdout.fileno(), os.O_BINARY)
3618
3866
        if parallel:
3619
3867
            self.additional_selftest_args.setdefault(
3620
3868
                'suite_decorators', []).append(parallel)
3621
3869
        if benchmark:
3622
 
            test_suite_factory = benchmarks.test_suite
3623
 
            # Unless user explicitly asks for quiet, be verbose in benchmarks
3624
 
            verbose = not is_quiet()
3625
 
            # TODO: should possibly lock the history file...
3626
 
            benchfile = open(".perf_history", "at", buffering=1)
3627
 
            self.add_cleanup(benchfile.close)
 
3870
            raise errors.BzrCommandError(
 
3871
                "--benchmark is no longer supported from bzr 2.2; "
 
3872
                "use bzr-usertest instead")
 
3873
        test_suite_factory = None
 
3874
        if not exclude:
 
3875
            exclude_pattern = None
3628
3876
        else:
3629
 
            test_suite_factory = None
3630
 
            benchfile = None
 
3877
            exclude_pattern = '(' + '|'.join(exclude) + ')'
 
3878
        if not sync:
 
3879
            self._disable_fsync()
3631
3880
        selftest_kwargs = {"verbose": verbose,
3632
3881
                          "pattern": pattern,
3633
3882
                          "stop_on_failure": one,
3635
3884
                          "test_suite_factory": test_suite_factory,
3636
3885
                          "lsprof_timed": lsprof_timed,
3637
3886
                          "lsprof_tests": lsprof_tests,
3638
 
                          "bench_history": benchfile,
3639
3887
                          "matching_tests_first": first,
3640
3888
                          "list_only": list_only,
3641
3889
                          "random_seed": randomize,
3642
 
                          "exclude_pattern": exclude,
 
3890
                          "exclude_pattern": exclude_pattern,
3643
3891
                          "strict": strict,
3644
3892
                          "load_list": load_list,
3645
3893
                          "debug_flags": debugflag,
3646
3894
                          "starting_with": starting_with
3647
3895
                          }
3648
3896
        selftest_kwargs.update(self.additional_selftest_args)
3649
 
        result = selftest(**selftest_kwargs)
 
3897
 
 
3898
        # Make deprecation warnings visible, unless -Werror is set
 
3899
        cleanup = symbol_versioning.activate_deprecation_warnings(
 
3900
            override=False)
 
3901
        try:
 
3902
            result = tests.selftest(**selftest_kwargs)
 
3903
        finally:
 
3904
            cleanup()
3650
3905
        return int(not result)
3651
3906
 
 
3907
    def _disable_fsync(self):
 
3908
        """Change the 'os' functionality to not synchronize."""
 
3909
        self._orig_fsync = getattr(os, 'fsync', None)
 
3910
        if self._orig_fsync is not None:
 
3911
            os.fsync = lambda filedes: None
 
3912
        self._orig_fdatasync = getattr(os, 'fdatasync', None)
 
3913
        if self._orig_fdatasync is not None:
 
3914
            os.fdatasync = lambda filedes: None
 
3915
 
3652
3916
 
3653
3917
class cmd_version(Command):
3654
3918
    __doc__ = """Show version of bzr."""
3690
3954
 
3691
3955
        branch1 = Branch.open_containing(branch)[0]
3692
3956
        branch2 = Branch.open_containing(other)[0]
3693
 
        branch1.lock_read()
3694
 
        self.add_cleanup(branch1.unlock)
3695
 
        branch2.lock_read()
3696
 
        self.add_cleanup(branch2.unlock)
 
3957
        self.add_cleanup(branch1.lock_read().unlock)
 
3958
        self.add_cleanup(branch2.lock_read().unlock)
3697
3959
        last1 = ensure_null(branch1.last_revision())
3698
3960
        last2 = ensure_null(branch2.last_revision())
3699
3961
 
3709
3971
    The source of the merge can be specified either in the form of a branch,
3710
3972
    or in the form of a path to a file containing a merge directive generated
3711
3973
    with bzr send. If neither is specified, the default is the upstream branch
3712
 
    or the branch most recently merged using --remember.
3713
 
 
3714
 
    When merging a branch, by default the tip will be merged. To pick a different
3715
 
    revision, pass --revision. If you specify two values, the first will be used as
3716
 
    BASE and the second one as OTHER. Merging individual revisions, or a subset of
3717
 
    available revisions, like this is commonly referred to as "cherrypicking".
3718
 
 
3719
 
    Revision numbers are always relative to the branch being merged.
3720
 
 
3721
 
    By default, bzr will try to merge in all new work from the other
3722
 
    branch, automatically determining an appropriate base.  If this
3723
 
    fails, you may need to give an explicit base.
 
3974
    or the branch most recently merged using --remember.  The source of the
 
3975
    merge may also be specified in the form of a path to a file in another
 
3976
    branch:  in this case, only the modifications to that file are merged into
 
3977
    the current working tree.
 
3978
 
 
3979
    When merging from a branch, by default bzr will try to merge in all new
 
3980
    work from the other branch, automatically determining an appropriate base
 
3981
    revision.  If this fails, you may need to give an explicit base.
 
3982
 
 
3983
    To pick a different ending revision, pass "--revision OTHER".  bzr will
 
3984
    try to merge in all new work up to and including revision OTHER.
 
3985
 
 
3986
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
 
3987
    through OTHER, excluding BASE but including OTHER, will be merged.  If this
 
3988
    causes some revisions to be skipped, i.e. if the destination branch does
 
3989
    not already contain revision BASE, such a merge is commonly referred to as
 
3990
    a "cherrypick". Unlike a normal merge, Bazaar does not currently track
 
3991
    cherrypicks. The changes look like a normal commit, and the history of the
 
3992
    changes from the other branch is not stored in the commit.
 
3993
 
 
3994
    Revision numbers are always relative to the source branch.
3724
3995
 
3725
3996
    Merge will do its best to combine the changes in two branches, but there
3726
3997
    are some kinds of problems only a human can fix.  When it encounters those,
3729
4000
 
3730
4001
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
3731
4002
 
3732
 
    If there is no default branch set, the first merge will set it. After
3733
 
    that, you can omit the branch to use the default.  To change the
3734
 
    default, use --remember. The value will only be saved if the remote
3735
 
    location can be accessed.
 
4003
    If there is no default branch set, the first merge will set it (use
 
4004
    --no-remember to avoid setting it). After that, you can omit the branch
 
4005
    to use the default.  To change the default, use --remember. The value will
 
4006
    only be saved if the remote location can be accessed.
3736
4007
 
3737
4008
    The results of the merge are placed into the destination working
3738
4009
    directory, where they can be reviewed (with bzr diff), tested, and then
3739
4010
    committed to record the result of the merge.
3740
4011
 
3741
4012
    merge refuses to run if there are any uncommitted changes, unless
3742
 
    --force is given. The --force option can also be used to create a
 
4013
    --force is given.  If --force is given, then the changes from the source 
 
4014
    will be merged with the current working tree, including any uncommitted
 
4015
    changes in the tree.  The --force option can also be used to create a
3743
4016
    merge revision which has more than two parents.
3744
4017
 
3745
4018
    If one would like to merge changes from the working tree of the other
3750
4023
    you to apply each diff hunk and file change, similar to "shelve".
3751
4024
 
3752
4025
    :Examples:
3753
 
        To merge the latest revision from bzr.dev::
 
4026
        To merge all new revisions from bzr.dev::
3754
4027
 
3755
4028
            bzr merge ../bzr.dev
3756
4029
 
3793
4066
                ' completely merged into the source, pull from the'
3794
4067
                ' source rather than merging.  When this happens,'
3795
4068
                ' you do not need to commit the result.'),
3796
 
        Option('directory',
 
4069
        custom_help('directory',
3797
4070
               help='Branch to merge into, '
3798
 
                    'rather than the one containing the working directory.',
3799
 
               short_name='d',
3800
 
               type=unicode,
3801
 
               ),
 
4071
                    'rather than the one containing the working directory.'),
3802
4072
        Option('preview', help='Instead of merging, show a diff of the'
3803
4073
               ' merge.'),
3804
4074
        Option('interactive', help='Select changes interactively.',
3806
4076
    ]
3807
4077
 
3808
4078
    def run(self, location=None, revision=None, force=False,
3809
 
            merge_type=None, show_base=False, reprocess=None, remember=False,
 
4079
            merge_type=None, show_base=False, reprocess=None, remember=None,
3810
4080
            uncommitted=False, pull=False,
3811
4081
            directory=None,
3812
4082
            preview=False,
3820
4090
        merger = None
3821
4091
        allow_pending = True
3822
4092
        verified = 'inapplicable'
 
4093
 
3823
4094
        tree = WorkingTree.open_containing(directory)[0]
 
4095
        if tree.branch.revno() == 0:
 
4096
            raise errors.BzrCommandError('Merging into empty branches not currently supported, '
 
4097
                                         'https://bugs.launchpad.net/bzr/+bug/308562')
3824
4098
 
3825
4099
        try:
3826
4100
            basis_tree = tree.revision_tree(tree.last_revision())
3837
4111
            unversioned_filter=tree.is_ignored, view_info=view_info)
3838
4112
        pb = ui.ui_factory.nested_progress_bar()
3839
4113
        self.add_cleanup(pb.finished)
3840
 
        tree.lock_write()
3841
 
        self.add_cleanup(tree.unlock)
 
4114
        self.add_cleanup(tree.lock_write().unlock)
3842
4115
        if location is not None:
3843
4116
            try:
3844
4117
                mergeable = bundle.read_mergeable_from_url(location,
3873
4146
        self.sanity_check_merger(merger)
3874
4147
        if (merger.base_rev_id == merger.other_rev_id and
3875
4148
            merger.other_rev_id is not None):
 
4149
            # check if location is a nonexistent file (and not a branch) to
 
4150
            # disambiguate the 'Nothing to do'
 
4151
            if merger.interesting_files:
 
4152
                if not merger.other_tree.has_filename(
 
4153
                    merger.interesting_files[0]):
 
4154
                    note("merger: " + str(merger))
 
4155
                    raise errors.PathsDoNotExist([location])
3876
4156
            note('Nothing to do.')
3877
4157
            return 0
3878
 
        if pull:
 
4158
        if pull and not preview:
3879
4159
            if merger.interesting_files is not None:
3880
4160
                raise errors.BzrCommandError('Cannot pull individual files')
3881
4161
            if (merger.base_rev_id == tree.last_revision()):
3905
4185
    def _do_preview(self, merger):
3906
4186
        from bzrlib.diff import show_diff_trees
3907
4187
        result_tree = self._get_preview(merger)
 
4188
        path_encoding = osutils.get_diff_header_encoding()
3908
4189
        show_diff_trees(merger.this_tree, result_tree, self.outf,
3909
 
                        old_label='', new_label='')
 
4190
                        old_label='', new_label='',
 
4191
                        path_encoding=path_encoding)
3910
4192
 
3911
4193
    def _do_merge(self, merger, change_reporter, allow_pending, verified):
3912
4194
        merger.change_reporter = change_reporter
3988
4270
        if other_revision_id is None:
3989
4271
            other_revision_id = _mod_revision.ensure_null(
3990
4272
                other_branch.last_revision())
3991
 
        # Remember where we merge from
3992
 
        if ((remember or tree.branch.get_submit_branch() is None) and
3993
 
             user_location is not None):
 
4273
        # Remember where we merge from. We need to remember if:
 
4274
        # - user specify a location (and we don't merge from the parent
 
4275
        #   branch)
 
4276
        # - user ask to remember or there is no previous location set to merge
 
4277
        #   from and user didn't ask to *not* remember
 
4278
        if (user_location is not None
 
4279
            and ((remember
 
4280
                  or (remember is None
 
4281
                      and tree.branch.get_submit_branch() is None)))):
3994
4282
            tree.branch.set_submit_branch(other_branch.base)
3995
 
        _merge_tags_if_possible(other_branch, tree.branch)
 
4283
        # Merge tags (but don't set them in the master branch yet, the user
 
4284
        # might revert this merge).  Commit will propagate them.
 
4285
        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)
3996
4286
        merger = _mod_merge.Merger.from_revision_ids(pb, tree,
3997
4287
            other_revision_id, base_revision_id, other_branch, base_branch)
3998
4288
        if other_path != '':
4099
4389
        from bzrlib.conflicts import restore
4100
4390
        if merge_type is None:
4101
4391
            merge_type = _mod_merge.Merge3Merger
4102
 
        tree, file_list = tree_files(file_list)
4103
 
        tree.lock_write()
4104
 
        self.add_cleanup(tree.unlock)
 
4392
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4393
        self.add_cleanup(tree.lock_write().unlock)
4105
4394
        parents = tree.get_parent_ids()
4106
4395
        if len(parents) != 2:
4107
4396
            raise errors.BzrCommandError("Sorry, remerge only works after normal"
4167
4456
    last committed revision is used.
4168
4457
 
4169
4458
    To remove only some changes, without reverting to a prior version, use
4170
 
    merge instead.  For example, "merge . --revision -2..-3" will remove the
4171
 
    changes introduced by -2, without affecting the changes introduced by -1.
4172
 
    Or to remove certain changes on a hunk-by-hunk basis, see the Shelf plugin.
 
4459
    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")
 
4460
    will remove the changes introduced by the second last commit (-2), without
 
4461
    affecting the changes introduced by the last commit (-1).  To remove
 
4462
    certain changes on a hunk-by-hunk basis, see the shelve command.
4173
4463
 
4174
4464
    By default, any files that have been manually changed will be backed up
4175
4465
    first.  (Files changed only by merge are not backed up.)  Backup files have
4205
4495
    target branches.
4206
4496
    """
4207
4497
 
4208
 
    _see_also = ['cat', 'export']
 
4498
    _see_also = ['cat', 'export', 'merge', 'shelve']
4209
4499
    takes_options = [
4210
4500
        'revision',
4211
4501
        Option('no-backup', "Do not save backups of reverted files."),
4216
4506
 
4217
4507
    def run(self, revision=None, no_backup=False, file_list=None,
4218
4508
            forget_merges=None):
4219
 
        tree, file_list = tree_files(file_list)
4220
 
        tree.lock_tree_write()
4221
 
        self.add_cleanup(tree.unlock)
 
4509
        tree, file_list = WorkingTree.open_containing_paths(file_list)
 
4510
        self.add_cleanup(tree.lock_tree_write().unlock)
4222
4511
        if forget_merges:
4223
4512
            tree.set_parent_ids(tree.get_parent_ids()[:1])
4224
4513
        else:
4313
4602
    _see_also = ['merge', 'pull']
4314
4603
    takes_args = ['other_branch?']
4315
4604
    takes_options = [
 
4605
        'directory',
4316
4606
        Option('reverse', 'Reverse the order of revisions.'),
4317
4607
        Option('mine-only',
4318
4608
               'Display changes in the local branch only.'),
4330
4620
            type=_parse_revision_str,
4331
4621
            help='Filter on local branch revisions (inclusive). '
4332
4622
                'See "help revisionspec" for details.'),
4333
 
        Option('include-merges',
 
4623
        Option('include-merged',
4334
4624
               'Show all revisions in addition to the mainline ones.'),
 
4625
        Option('include-merges', hidden=True,
 
4626
               help='Historical alias for --include-merged.'),
4335
4627
        ]
4336
4628
    encoding_type = 'replace'
4337
4629
 
4340
4632
            theirs_only=False,
4341
4633
            log_format=None, long=False, short=False, line=False,
4342
4634
            show_ids=False, verbose=False, this=False, other=False,
4343
 
            include_merges=False, revision=None, my_revision=None):
 
4635
            include_merged=None, revision=None, my_revision=None,
 
4636
            directory=u'.',
 
4637
            include_merges=symbol_versioning.DEPRECATED_PARAMETER):
4344
4638
        from bzrlib.missing import find_unmerged, iter_log_revisions
4345
4639
        def message(s):
4346
4640
            if not is_quiet():
4347
4641
                self.outf.write(s)
4348
4642
 
 
4643
        if symbol_versioning.deprecated_passed(include_merges):
 
4644
            ui.ui_factory.show_user_warning(
 
4645
                'deprecated_command_option',
 
4646
                deprecated_name='--include-merges',
 
4647
                recommended_name='--include-merged',
 
4648
                deprecated_in_version='2.5',
 
4649
                command=self.invoked_as)
 
4650
            if include_merged is None:
 
4651
                include_merged = include_merges
 
4652
            else:
 
4653
                raise errors.BzrCommandError(
 
4654
                    '--include-merges and --include-merged '
 
4655
                    'are mutually exclusive')
 
4656
        if include_merged is None:
 
4657
            include_merged = False
4349
4658
        if this:
4350
4659
            mine_only = this
4351
4660
        if other:
4359
4668
        elif theirs_only:
4360
4669
            restrict = 'remote'
4361
4670
 
4362
 
        local_branch = Branch.open_containing(u".")[0]
4363
 
        local_branch.lock_read()
4364
 
        self.add_cleanup(local_branch.unlock)
 
4671
        local_branch = Branch.open_containing(directory)[0]
 
4672
        self.add_cleanup(local_branch.lock_read().unlock)
4365
4673
 
4366
4674
        parent = local_branch.get_parent()
4367
4675
        if other_branch is None:
4378
4686
        if remote_branch.base == local_branch.base:
4379
4687
            remote_branch = local_branch
4380
4688
        else:
4381
 
            remote_branch.lock_read()
4382
 
            self.add_cleanup(remote_branch.unlock)
 
4689
            self.add_cleanup(remote_branch.lock_read().unlock)
4383
4690
 
4384
4691
        local_revid_range = _revision_range_to_revid_range(
4385
4692
            _get_revision_range(my_revision, local_branch,
4392
4699
        local_extra, remote_extra = find_unmerged(
4393
4700
            local_branch, remote_branch, restrict,
4394
4701
            backward=not reverse,
4395
 
            include_merges=include_merges,
 
4702
            include_merged=include_merged,
4396
4703
            local_revid_range=local_revid_range,
4397
4704
            remote_revid_range=remote_revid_range)
4398
4705
 
4429
4736
 
4430
4737
        if mine_only and not local_extra:
4431
4738
            # We checked local, and found nothing extra
4432
 
            message('This branch is up to date.\n')
 
4739
            message('This branch has no new revisions.\n')
4433
4740
        elif theirs_only and not remote_extra:
4434
4741
            # We checked remote, and found nothing extra
4435
 
            message('Other branch is up to date.\n')
 
4742
            message('Other branch has no new revisions.\n')
4436
4743
        elif not (mine_only or theirs_only or local_extra or
4437
4744
                  remote_extra):
4438
4745
            # We checked both branches, and neither one had extra
4440
4747
            message("Branches are up to date.\n")
4441
4748
        self.cleanup_now()
4442
4749
        if not status_code and parent is None and other_branch is not None:
4443
 
            local_branch.lock_write()
4444
 
            self.add_cleanup(local_branch.unlock)
 
4750
            self.add_cleanup(local_branch.lock_write().unlock)
4445
4751
            # handle race conditions - a parent might be set while we run.
4446
4752
            if local_branch.get_parent() is None:
4447
4753
                local_branch.set_parent(remote_branch.base)
4506
4812
 
4507
4813
    @display_command
4508
4814
    def run(self, verbose=False):
4509
 
        import bzrlib.plugin
4510
 
        from inspect import getdoc
4511
 
        result = []
4512
 
        for name, plugin in bzrlib.plugin.plugins().items():
4513
 
            version = plugin.__version__
4514
 
            if version == 'unknown':
4515
 
                version = ''
4516
 
            name_ver = '%s %s' % (name, version)
4517
 
            d = getdoc(plugin.module)
4518
 
            if d:
4519
 
                doc = d.split('\n')[0]
4520
 
            else:
4521
 
                doc = '(no description)'
4522
 
            result.append((name_ver, doc, plugin.path()))
4523
 
        for name_ver, doc, path in sorted(result):
4524
 
            self.outf.write("%s\n" % name_ver)
4525
 
            self.outf.write("   %s\n" % doc)
4526
 
            if verbose:
4527
 
                self.outf.write("   %s\n" % path)
4528
 
            self.outf.write("\n")
 
4815
        from bzrlib import plugin
 
4816
        # Don't give writelines a generator as some codecs don't like that
 
4817
        self.outf.writelines(
 
4818
            list(plugin.describe_plugins(show_paths=verbose)))
4529
4819
 
4530
4820
 
4531
4821
class cmd_testament(Command):
4547
4837
            b = Branch.open_containing(branch)[0]
4548
4838
        else:
4549
4839
            b = Branch.open(branch)
4550
 
        b.lock_read()
4551
 
        self.add_cleanup(b.unlock)
 
4840
        self.add_cleanup(b.lock_read().unlock)
4552
4841
        if revision is None:
4553
4842
            rev_id = b.last_revision()
4554
4843
        else:
4578
4867
                     Option('long', help='Show commit date in annotations.'),
4579
4868
                     'revision',
4580
4869
                     'show-ids',
 
4870
                     'directory',
4581
4871
                     ]
4582
4872
    encoding_type = 'exact'
4583
4873
 
4584
4874
    @display_command
4585
4875
    def run(self, filename, all=False, long=False, revision=None,
4586
 
            show_ids=False):
4587
 
        from bzrlib.annotate import annotate_file, annotate_file_tree
 
4876
            show_ids=False, directory=None):
 
4877
        from bzrlib.annotate import (
 
4878
            annotate_file_tree,
 
4879
            )
4588
4880
        wt, branch, relpath = \
4589
 
            bzrdir.BzrDir.open_containing_tree_or_branch(filename)
 
4881
            _open_directory_or_containing_tree_or_branch(filename, directory)
4590
4882
        if wt is not None:
4591
 
            wt.lock_read()
4592
 
            self.add_cleanup(wt.unlock)
 
4883
            self.add_cleanup(wt.lock_read().unlock)
4593
4884
        else:
4594
 
            branch.lock_read()
4595
 
            self.add_cleanup(branch.unlock)
 
4885
            self.add_cleanup(branch.lock_read().unlock)
4596
4886
        tree = _get_one_revision_tree('annotate', revision, branch=branch)
4597
 
        tree.lock_read()
4598
 
        self.add_cleanup(tree.unlock)
4599
 
        if wt is not None:
 
4887
        self.add_cleanup(tree.lock_read().unlock)
 
4888
        if wt is not None and revision is None:
4600
4889
            file_id = wt.path2id(relpath)
4601
4890
        else:
4602
4891
            file_id = tree.path2id(relpath)
4603
4892
        if file_id is None:
4604
4893
            raise errors.NotVersionedError(filename)
4605
 
        file_version = tree.inventory[file_id].revision
4606
4894
        if wt is not None and revision is None:
4607
4895
            # If there is a tree and we're not annotating historical
4608
4896
            # versions, annotate the working tree's content.
4609
4897
            annotate_file_tree(wt, file_id, self.outf, long, all,
4610
4898
                show_ids=show_ids)
4611
4899
        else:
4612
 
            annotate_file(branch, file_version, file_id, long, all, self.outf,
4613
 
                          show_ids=show_ids)
 
4900
            annotate_file_tree(tree, file_id, self.outf, long, all,
 
4901
                show_ids=show_ids, branch=branch)
4614
4902
 
4615
4903
 
4616
4904
class cmd_re_sign(Command):
4619
4907
 
4620
4908
    hidden = True # is this right ?
4621
4909
    takes_args = ['revision_id*']
4622
 
    takes_options = ['revision']
 
4910
    takes_options = ['directory', 'revision']
4623
4911
 
4624
 
    def run(self, revision_id_list=None, revision=None):
 
4912
    def run(self, revision_id_list=None, revision=None, directory=u'.'):
4625
4913
        if revision_id_list is not None and revision is not None:
4626
4914
            raise errors.BzrCommandError('You can only supply one of revision_id or --revision')
4627
4915
        if revision_id_list is None and revision is None:
4628
4916
            raise errors.BzrCommandError('You must supply either --revision or a revision_id')
4629
 
        b = WorkingTree.open_containing(u'.')[0].branch
4630
 
        b.lock_write()
4631
 
        self.add_cleanup(b.unlock)
 
4917
        b = WorkingTree.open_containing(directory)[0].branch
 
4918
        self.add_cleanup(b.lock_write().unlock)
4632
4919
        return self._run(b, revision_id_list, revision)
4633
4920
 
4634
4921
    def _run(self, b, revision_id_list, revision):
4693
4980
 
4694
4981
    _see_also = ['checkouts', 'unbind']
4695
4982
    takes_args = ['location?']
4696
 
    takes_options = []
 
4983
    takes_options = ['directory']
4697
4984
 
4698
 
    def run(self, location=None):
4699
 
        b, relpath = Branch.open_containing(u'.')
 
4985
    def run(self, location=None, directory=u'.'):
 
4986
        b, relpath = Branch.open_containing(directory)
4700
4987
        if location is None:
4701
4988
            try:
4702
4989
                location = b.get_old_bound_location()
4729
5016
 
4730
5017
    _see_also = ['checkouts', 'bind']
4731
5018
    takes_args = []
4732
 
    takes_options = []
 
5019
    takes_options = ['directory']
4733
5020
 
4734
 
    def run(self):
4735
 
        b, relpath = Branch.open_containing(u'.')
 
5021
    def run(self, directory=u'.'):
 
5022
        b, relpath = Branch.open_containing(directory)
4736
5023
        if not b.unbind():
4737
5024
            raise errors.BzrCommandError('Local branch is not bound')
4738
5025
 
4761
5048
    takes_options = ['verbose', 'revision',
4762
5049
                    Option('dry-run', help='Don\'t actually make changes.'),
4763
5050
                    Option('force', help='Say yes to all questions.'),
 
5051
                    Option('keep-tags',
 
5052
                           help='Keep tags that point to removed revisions.'),
4764
5053
                    Option('local',
4765
5054
                           help="Only remove the commits from the local branch"
4766
5055
                                " when in a checkout."
4770
5059
    aliases = []
4771
5060
    encoding_type = 'replace'
4772
5061
 
4773
 
    def run(self, location=None,
4774
 
            dry_run=False, verbose=False,
4775
 
            revision=None, force=False, local=False):
 
5062
    def run(self, location=None, dry_run=False, verbose=False,
 
5063
            revision=None, force=False, local=False, keep_tags=False):
4776
5064
        if location is None:
4777
5065
            location = u'.'
4778
5066
        control, relpath = bzrdir.BzrDir.open_containing(location)
4784
5072
            b = control.open_branch()
4785
5073
 
4786
5074
        if tree is not None:
4787
 
            tree.lock_write()
4788
 
            self.add_cleanup(tree.unlock)
 
5075
            self.add_cleanup(tree.lock_write().unlock)
4789
5076
        else:
4790
 
            b.lock_write()
4791
 
            self.add_cleanup(b.unlock)
4792
 
        return self._run(b, tree, dry_run, verbose, revision, force, local=local)
 
5077
            self.add_cleanup(b.lock_write().unlock)
 
5078
        return self._run(b, tree, dry_run, verbose, revision, force,
 
5079
                         local, keep_tags)
4793
5080
 
4794
 
    def _run(self, b, tree, dry_run, verbose, revision, force, local=False):
 
5081
    def _run(self, b, tree, dry_run, verbose, revision, force, local,
 
5082
             keep_tags):
4795
5083
        from bzrlib.log import log_formatter, show_log
4796
5084
        from bzrlib.uncommit import uncommit
4797
5085
 
4833
5121
            self.outf.write('The above revision(s) will be removed.\n')
4834
5122
 
4835
5123
        if not force:
4836
 
            if not ui.ui_factory.get_boolean('Are you sure'):
4837
 
                self.outf.write('Canceled')
 
5124
            if not ui.ui_factory.confirm_action(
 
5125
                    u'Uncommit these revisions',
 
5126
                    'bzrlib.builtins.uncommit',
 
5127
                    {}):
 
5128
                self.outf.write('Canceled\n')
4838
5129
                return 0
4839
5130
 
4840
5131
        mutter('Uncommitting from {%s} to {%s}',
4841
5132
               last_rev_id, rev_id)
4842
5133
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
4843
 
                 revno=revno, local=local)
 
5134
                 revno=revno, local=local, keep_tags=keep_tags)
4844
5135
        self.outf.write('You can restore the old tip by running:\n'
4845
5136
             '  bzr pull . -r revid:%s\n' % last_rev_id)
4846
5137
 
4847
5138
 
4848
5139
class cmd_break_lock(Command):
4849
 
    __doc__ = """Break a dead lock on a repository, branch or working directory.
 
5140
    __doc__ = """Break a dead lock.
 
5141
 
 
5142
    This command breaks a lock on a repository, branch, working directory or
 
5143
    config file.
4850
5144
 
4851
5145
    CAUTION: Locks should only be broken when you are sure that the process
4852
5146
    holding the lock has been stopped.
4857
5151
    :Examples:
4858
5152
        bzr break-lock
4859
5153
        bzr break-lock bzr+ssh://example.com/bzr/foo
 
5154
        bzr break-lock --conf ~/.bazaar
4860
5155
    """
 
5156
 
4861
5157
    takes_args = ['location?']
 
5158
    takes_options = [
 
5159
        Option('config',
 
5160
               help='LOCATION is the directory where the config lock is.'),
 
5161
        Option('force',
 
5162
            help='Do not ask for confirmation before breaking the lock.'),
 
5163
        ]
4862
5164
 
4863
 
    def run(self, location=None, show=False):
 
5165
    def run(self, location=None, config=False, force=False):
4864
5166
        if location is None:
4865
5167
            location = u'.'
4866
 
        control, relpath = bzrdir.BzrDir.open_containing(location)
4867
 
        try:
4868
 
            control.break_lock()
4869
 
        except NotImplementedError:
4870
 
            pass
 
5168
        if force:
 
5169
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
 
5170
                None,
 
5171
                {'bzrlib.lockdir.break': True})
 
5172
        if config:
 
5173
            conf = _mod_config.LockableConfig(file_name=location)
 
5174
            conf.break_lock()
 
5175
        else:
 
5176
            control, relpath = bzrdir.BzrDir.open_containing(location)
 
5177
            try:
 
5178
                control.break_lock()
 
5179
            except NotImplementedError:
 
5180
                pass
4871
5181
 
4872
5182
 
4873
5183
class cmd_wait_until_signalled(Command):
4902
5212
                    'result in a dynamically allocated port.  The default port '
4903
5213
                    'depends on the protocol.',
4904
5214
               type=str),
4905
 
        Option('directory',
4906
 
               help='Serve contents of this directory.',
4907
 
               type=unicode),
 
5215
        custom_help('directory',
 
5216
               help='Serve contents of this directory.'),
4908
5217
        Option('allow-writes',
4909
5218
               help='By default the server is a readonly server.  Supplying '
4910
5219
                    '--allow-writes enables write access to the contents of '
4937
5246
 
4938
5247
    def run(self, port=None, inet=False, directory=None, allow_writes=False,
4939
5248
            protocol=None):
4940
 
        from bzrlib.transport import get_transport, transport_server_registry
 
5249
        from bzrlib import transport
4941
5250
        if directory is None:
4942
5251
            directory = os.getcwd()
4943
5252
        if protocol is None:
4944
 
            protocol = transport_server_registry.get()
 
5253
            protocol = transport.transport_server_registry.get()
4945
5254
        host, port = self.get_host_and_port(port)
4946
5255
        url = urlutils.local_path_to_url(directory)
4947
5256
        if not allow_writes:
4948
5257
            url = 'readonly+' + url
4949
 
        transport = get_transport(url)
4950
 
        protocol(transport, host, port, inet)
 
5258
        t = transport.get_transport(url)
 
5259
        protocol(t, host, port, inet)
4951
5260
 
4952
5261
 
4953
5262
class cmd_join(Command):
4959
5268
    not part of it.  (Such trees can be produced by "bzr split", but also by
4960
5269
    running "bzr branch" with the target inside a tree.)
4961
5270
 
4962
 
    The result is a combined tree, with the subtree no longer an independant
 
5271
    The result is a combined tree, with the subtree no longer an independent
4963
5272
    part.  This is marked as a merge of the subtree into the containing tree,
4964
5273
    and all history is preserved.
4965
5274
    """
5046
5355
    _see_also = ['send']
5047
5356
 
5048
5357
    takes_options = [
 
5358
        'directory',
5049
5359
        RegistryOption.from_kwargs('patch-type',
5050
5360
            'The type of patch to include in the directive.',
5051
5361
            title='Patch type',
5064
5374
    encoding_type = 'exact'
5065
5375
 
5066
5376
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5067
 
            sign=False, revision=None, mail_to=None, message=None):
 
5377
            sign=False, revision=None, mail_to=None, message=None,
 
5378
            directory=u'.'):
5068
5379
        from bzrlib.revision import ensure_null, NULL_REVISION
5069
5380
        include_patch, include_bundle = {
5070
5381
            'plain': (False, False),
5071
5382
            'diff': (True, False),
5072
5383
            'bundle': (True, True),
5073
5384
            }[patch_type]
5074
 
        branch = Branch.open('.')
 
5385
        branch = Branch.open(directory)
5075
5386
        stored_submit_branch = branch.get_submit_branch()
5076
5387
        if submit_branch is None:
5077
5388
            submit_branch = stored_submit_branch
5153
5464
    source branch defaults to that containing the working directory, but can
5154
5465
    be changed using --from.
5155
5466
 
 
5467
    Both the submit branch and the public branch follow the usual behavior with
 
5468
    respect to --remember: If there is no default location set, the first send
 
5469
    will set it (use --no-remember to avoid setting it). After that, you can
 
5470
    omit the location to use the default.  To change the default, use
 
5471
    --remember. The value will only be saved if the location can be accessed.
 
5472
 
5156
5473
    In order to calculate those changes, bzr must analyse the submit branch.
5157
5474
    Therefore it is most efficient for the submit branch to be a local mirror.
5158
5475
    If a public location is known for the submit_branch, that location is used
5162
5479
    given, in which case it is sent to a file.
5163
5480
 
5164
5481
    Mail is sent using your preferred mail program.  This should be transparent
5165
 
    on Windows (it uses MAPI).  On Linux, it requires the xdg-email utility.
 
5482
    on Windows (it uses MAPI).  On Unix, it requires the xdg-email utility.
5166
5483
    If the preferred client can't be found (or used), your editor will be used.
5167
5484
 
5168
5485
    To use a specific mail program, set the mail_client configuration option.
5227
5544
        ]
5228
5545
 
5229
5546
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5230
 
            no_patch=False, revision=None, remember=False, output=None,
 
5547
            no_patch=False, revision=None, remember=None, output=None,
5231
5548
            format=None, mail_to=None, message=None, body=None,
5232
5549
            strict=None, **kwargs):
5233
5550
        from bzrlib.send import send
5339
5656
        Option('delete',
5340
5657
            help='Delete this tag rather than placing it.',
5341
5658
            ),
5342
 
        Option('directory',
5343
 
            help='Branch in which to place the tag.',
5344
 
            short_name='d',
5345
 
            type=unicode,
5346
 
            ),
 
5659
        custom_help('directory',
 
5660
            help='Branch in which to place the tag.'),
5347
5661
        Option('force',
5348
5662
            help='Replace existing tags.',
5349
5663
            ),
5357
5671
            revision=None,
5358
5672
            ):
5359
5673
        branch, relpath = Branch.open_containing(directory)
5360
 
        branch.lock_write()
5361
 
        self.add_cleanup(branch.unlock)
 
5674
        self.add_cleanup(branch.lock_write().unlock)
5362
5675
        if delete:
5363
5676
            if tag_name is None:
5364
5677
                raise errors.BzrCommandError("No tag specified to delete.")
5365
5678
            branch.tags.delete_tag(tag_name)
5366
 
            self.outf.write('Deleted tag %s.\n' % tag_name)
 
5679
            note('Deleted tag %s.' % tag_name)
5367
5680
        else:
5368
5681
            if revision:
5369
5682
                if len(revision) != 1:
5378
5691
                if tag_name is None:
5379
5692
                    raise errors.BzrCommandError(
5380
5693
                        "Please specify a tag name.")
5381
 
            if (not force) and branch.tags.has_tag(tag_name):
 
5694
            try:
 
5695
                existing_target = branch.tags.lookup_tag(tag_name)
 
5696
            except errors.NoSuchTag:
 
5697
                existing_target = None
 
5698
            if not force and existing_target not in (None, revision_id):
5382
5699
                raise errors.TagAlreadyExists(tag_name)
5383
 
            branch.tags.set_tag(tag_name, revision_id)
5384
 
            self.outf.write('Created tag %s.\n' % tag_name)
 
5700
            if existing_target == revision_id:
 
5701
                note('Tag %s already exists for that revision.' % tag_name)
 
5702
            else:
 
5703
                branch.tags.set_tag(tag_name, revision_id)
 
5704
                if existing_target is None:
 
5705
                    note('Created tag %s.' % tag_name)
 
5706
                else:
 
5707
                    note('Updated tag %s.' % tag_name)
5385
5708
 
5386
5709
 
5387
5710
class cmd_tags(Command):
5392
5715
 
5393
5716
    _see_also = ['tag']
5394
5717
    takes_options = [
5395
 
        Option('directory',
5396
 
            help='Branch whose tags should be displayed.',
5397
 
            short_name='d',
5398
 
            type=unicode,
5399
 
            ),
5400
 
        RegistryOption.from_kwargs('sort',
 
5718
        custom_help('directory',
 
5719
            help='Branch whose tags should be displayed.'),
 
5720
        RegistryOption('sort',
5401
5721
            'Sort tags by different criteria.', title='Sorting',
5402
 
            alpha='Sort tags lexicographically (default).',
5403
 
            time='Sort tags chronologically.',
 
5722
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
5404
5723
            ),
5405
5724
        'show-ids',
5406
5725
        'revision',
5407
5726
    ]
5408
5727
 
5409
5728
    @display_command
5410
 
    def run(self,
5411
 
            directory='.',
5412
 
            sort='alpha',
5413
 
            show_ids=False,
5414
 
            revision=None,
5415
 
            ):
 
5729
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
 
5730
        from bzrlib.tag import tag_sort_methods
5416
5731
        branch, relpath = Branch.open_containing(directory)
5417
5732
 
5418
5733
        tags = branch.tags.get_tag_dict().items()
5419
5734
        if not tags:
5420
5735
            return
5421
5736
 
5422
 
        branch.lock_read()
5423
 
        self.add_cleanup(branch.unlock)
 
5737
        self.add_cleanup(branch.lock_read().unlock)
5424
5738
        if revision:
5425
5739
            graph = branch.repository.get_graph()
5426
5740
            rev1, rev2 = _get_revision_range(revision, branch, self.name())
5428
5742
            # only show revisions between revid1 and revid2 (inclusive)
5429
5743
            tags = [(tag, revid) for tag, revid in tags if
5430
5744
                graph.is_between(revid, revid1, revid2)]
5431
 
        if sort == 'alpha':
5432
 
            tags.sort()
5433
 
        elif sort == 'time':
5434
 
            timestamps = {}
5435
 
            for tag, revid in tags:
5436
 
                try:
5437
 
                    revobj = branch.repository.get_revision(revid)
5438
 
                except errors.NoSuchRevision:
5439
 
                    timestamp = sys.maxint # place them at the end
5440
 
                else:
5441
 
                    timestamp = revobj.timestamp
5442
 
                timestamps[revid] = timestamp
5443
 
            tags.sort(key=lambda x: timestamps[x[1]])
 
5745
        if sort is None:
 
5746
            sort = tag_sort_methods.get()
 
5747
        sort(branch, tags)
5444
5748
        if not show_ids:
5445
5749
            # [ (tag, revid), ... ] -> [ (tag, dotted_revno), ... ]
5446
5750
            for index, (tag, revid) in enumerate(tags):
5448
5752
                    revno = branch.revision_id_to_dotted_revno(revid)
5449
5753
                    if isinstance(revno, tuple):
5450
5754
                        revno = '.'.join(map(str, revno))
5451
 
                except errors.NoSuchRevision:
 
5755
                except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):
5452
5756
                    # Bad tag data/merges can lead to tagged revisions
5453
5757
                    # which are not in this branch. Fail gracefully ...
5454
5758
                    revno = '?'
5476
5780
    takes_args = ['location?']
5477
5781
    takes_options = [
5478
5782
        RegistryOption.from_kwargs(
5479
 
            'target_type',
5480
 
            title='Target type',
5481
 
            help='The type to reconfigure the directory to.',
 
5783
            'tree_type',
 
5784
            title='Tree type',
 
5785
            help='The relation between branch and tree.',
5482
5786
            value_switches=True, enum_switch=False,
5483
5787
            branch='Reconfigure to be an unbound branch with no working tree.',
5484
5788
            tree='Reconfigure to be an unbound branch with a working tree.',
5485
5789
            checkout='Reconfigure to be a bound branch with a working tree.',
5486
5790
            lightweight_checkout='Reconfigure to be a lightweight'
5487
5791
                ' checkout (with no local history).',
 
5792
            ),
 
5793
        RegistryOption.from_kwargs(
 
5794
            'repository_type',
 
5795
            title='Repository type',
 
5796
            help='Location fo the repository.',
 
5797
            value_switches=True, enum_switch=False,
5488
5798
            standalone='Reconfigure to be a standalone branch '
5489
5799
                '(i.e. stop using shared repository).',
5490
5800
            use_shared='Reconfigure to use a shared repository.',
 
5801
            ),
 
5802
        RegistryOption.from_kwargs(
 
5803
            'repository_trees',
 
5804
            title='Trees in Repository',
 
5805
            help='Whether new branches in the repository have trees.',
 
5806
            value_switches=True, enum_switch=False,
5491
5807
            with_trees='Reconfigure repository to create '
5492
5808
                'working trees on branches by default.',
5493
5809
            with_no_trees='Reconfigure repository to not create '
5507
5823
            ),
5508
5824
        ]
5509
5825
 
5510
 
    def run(self, location=None, target_type=None, bind_to=None, force=False,
5511
 
            stacked_on=None,
5512
 
            unstacked=None):
 
5826
    def run(self, location=None, bind_to=None, force=False,
 
5827
            tree_type=None, repository_type=None, repository_trees=None,
 
5828
            stacked_on=None, unstacked=None):
5513
5829
        directory = bzrdir.BzrDir.open(location)
5514
5830
        if stacked_on and unstacked:
5515
 
            raise BzrCommandError("Can't use both --stacked-on and --unstacked")
 
5831
            raise errors.BzrCommandError("Can't use both --stacked-on and --unstacked")
5516
5832
        elif stacked_on is not None:
5517
5833
            reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)
5518
5834
        elif unstacked:
5520
5836
        # At the moment you can use --stacked-on and a different
5521
5837
        # reconfiguration shape at the same time; there seems no good reason
5522
5838
        # to ban it.
5523
 
        if target_type is None:
 
5839
        if (tree_type is None and
 
5840
            repository_type is None and
 
5841
            repository_trees is None):
5524
5842
            if stacked_on or unstacked:
5525
5843
                return
5526
5844
            else:
5527
5845
                raise errors.BzrCommandError('No target configuration '
5528
5846
                    'specified')
5529
 
        elif target_type == 'branch':
 
5847
        reconfiguration = None
 
5848
        if tree_type == 'branch':
5530
5849
            reconfiguration = reconfigure.Reconfigure.to_branch(directory)
5531
 
        elif target_type == 'tree':
 
5850
        elif tree_type == 'tree':
5532
5851
            reconfiguration = reconfigure.Reconfigure.to_tree(directory)
5533
 
        elif target_type == 'checkout':
 
5852
        elif tree_type == 'checkout':
5534
5853
            reconfiguration = reconfigure.Reconfigure.to_checkout(
5535
5854
                directory, bind_to)
5536
 
        elif target_type == 'lightweight-checkout':
 
5855
        elif tree_type == 'lightweight-checkout':
5537
5856
            reconfiguration = reconfigure.Reconfigure.to_lightweight_checkout(
5538
5857
                directory, bind_to)
5539
 
        elif target_type == 'use-shared':
 
5858
        if reconfiguration:
 
5859
            reconfiguration.apply(force)
 
5860
            reconfiguration = None
 
5861
        if repository_type == 'use-shared':
5540
5862
            reconfiguration = reconfigure.Reconfigure.to_use_shared(directory)
5541
 
        elif target_type == 'standalone':
 
5863
        elif repository_type == 'standalone':
5542
5864
            reconfiguration = reconfigure.Reconfigure.to_standalone(directory)
5543
 
        elif target_type == 'with-trees':
 
5865
        if reconfiguration:
 
5866
            reconfiguration.apply(force)
 
5867
            reconfiguration = None
 
5868
        if repository_trees == 'with-trees':
5544
5869
            reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5545
5870
                directory, True)
5546
 
        elif target_type == 'with-no-trees':
 
5871
        elif repository_trees == 'with-no-trees':
5547
5872
            reconfiguration = reconfigure.Reconfigure.set_repository_trees(
5548
5873
                directory, False)
5549
 
        reconfiguration.apply(force)
 
5874
        if reconfiguration:
 
5875
            reconfiguration.apply(force)
 
5876
            reconfiguration = None
5550
5877
 
5551
5878
 
5552
5879
class cmd_switch(Command):
5573
5900
    """
5574
5901
 
5575
5902
    takes_args = ['to_location?']
5576
 
    takes_options = [Option('force',
 
5903
    takes_options = ['directory',
 
5904
                     Option('force',
5577
5905
                        help='Switch even if local commits will be lost.'),
5578
5906
                     'revision',
5579
5907
                     Option('create-branch', short_name='b',
5582
5910
                    ]
5583
5911
 
5584
5912
    def run(self, to_location=None, force=False, create_branch=False,
5585
 
            revision=None):
 
5913
            revision=None, directory=u'.'):
5586
5914
        from bzrlib import switch
5587
 
        tree_location = '.'
 
5915
        tree_location = directory
5588
5916
        revision = _get_one_revision('switch', revision)
5589
5917
        control_dir = bzrdir.BzrDir.open_containing(tree_location)[0]
5590
5918
        if to_location is None:
5591
5919
            if revision is None:
5592
5920
                raise errors.BzrCommandError('You must supply either a'
5593
5921
                                             ' revision or a location')
5594
 
            to_location = '.'
 
5922
            to_location = tree_location
5595
5923
        try:
5596
5924
            branch = control_dir.open_branch()
5597
5925
            had_explicit_nick = branch.get_config().has_explicit_nickname()
5732
6060
            name=None,
5733
6061
            switch=None,
5734
6062
            ):
5735
 
        tree, file_list = tree_files(file_list, apply_view=False)
 
6063
        tree, file_list = WorkingTree.open_containing_paths(file_list,
 
6064
            apply_view=False)
5736
6065
        current_view, view_dict = tree.views.get_view_info()
5737
6066
        if name is None:
5738
6067
            name = current_view
5842
6171
            location = "."
5843
6172
        branch = Branch.open_containing(location)[0]
5844
6173
        branch.bzrdir.destroy_branch()
5845
 
        
 
6174
 
5846
6175
 
5847
6176
class cmd_shelve(Command):
5848
6177
    __doc__ = """Temporarily set aside some changes from the current tree.
5867
6196
 
5868
6197
    You can put multiple items on the shelf, and by default, 'unshelve' will
5869
6198
    restore the most recently shelved changes.
 
6199
 
 
6200
    For complicated changes, it is possible to edit the changes in a separate
 
6201
    editor program to decide what the file remaining in the working copy
 
6202
    should look like.  To do this, add the configuration option
 
6203
 
 
6204
        change_editor = PROGRAM @new_path @old_path
 
6205
 
 
6206
    where @new_path is replaced with the path of the new version of the 
 
6207
    file and @old_path is replaced with the path of the old version of 
 
6208
    the file.  The PROGRAM should save the new file with the desired 
 
6209
    contents of the file in the working tree.
 
6210
        
5870
6211
    """
5871
6212
 
5872
6213
    takes_args = ['file*']
5873
6214
 
5874
6215
    takes_options = [
 
6216
        'directory',
5875
6217
        'revision',
5876
6218
        Option('all', help='Shelve all changes.'),
5877
6219
        'message',
5883
6225
        Option('destroy',
5884
6226
               help='Destroy removed changes instead of shelving them.'),
5885
6227
    ]
5886
 
    _see_also = ['unshelve']
 
6228
    _see_also = ['unshelve', 'configuration']
5887
6229
 
5888
6230
    def run(self, revision=None, all=False, file_list=None, message=None,
5889
 
            writer=None, list=False, destroy=False):
 
6231
            writer=None, list=False, destroy=False, directory=None):
5890
6232
        if list:
5891
 
            return self.run_for_list()
 
6233
            return self.run_for_list(directory=directory)
5892
6234
        from bzrlib.shelf_ui import Shelver
5893
6235
        if writer is None:
5894
6236
            writer = bzrlib.option.diff_writer_registry.get()
5895
6237
        try:
5896
6238
            shelver = Shelver.from_args(writer(sys.stdout), revision, all,
5897
 
                file_list, message, destroy=destroy)
 
6239
                file_list, message, destroy=destroy, directory=directory)
5898
6240
            try:
5899
6241
                shelver.run()
5900
6242
            finally:
5902
6244
        except errors.UserAbort:
5903
6245
            return 0
5904
6246
 
5905
 
    def run_for_list(self):
5906
 
        tree = WorkingTree.open_containing('.')[0]
5907
 
        tree.lock_read()
5908
 
        self.add_cleanup(tree.unlock)
 
6247
    def run_for_list(self, directory=None):
 
6248
        if directory is None:
 
6249
            directory = u'.'
 
6250
        tree = WorkingTree.open_containing(directory)[0]
 
6251
        self.add_cleanup(tree.lock_read().unlock)
5909
6252
        manager = tree.get_shelf_manager()
5910
6253
        shelves = manager.active_shelves()
5911
6254
        if len(shelves) == 0:
5929
6272
 
5930
6273
    takes_args = ['shelf_id?']
5931
6274
    takes_options = [
 
6275
        'directory',
5932
6276
        RegistryOption.from_kwargs(
5933
6277
            'action', help="The action to perform.",
5934
6278
            enum_switch=False, value_switches=True,
5942
6286
    ]
5943
6287
    _see_also = ['shelve']
5944
6288
 
5945
 
    def run(self, shelf_id=None, action='apply'):
 
6289
    def run(self, shelf_id=None, action='apply', directory=u'.'):
5946
6290
        from bzrlib.shelf_ui import Unshelver
5947
 
        unshelver = Unshelver.from_args(shelf_id, action)
 
6291
        unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
5948
6292
        try:
5949
6293
            unshelver.run()
5950
6294
        finally:
5966
6310
 
5967
6311
    To check what clean-tree will do, use --dry-run.
5968
6312
    """
5969
 
    takes_options = [Option('ignored', help='Delete all ignored files.'),
5970
 
                     Option('detritus', help='Delete conflict files, merge'
 
6313
    takes_options = ['directory',
 
6314
                     Option('ignored', help='Delete all ignored files.'),
 
6315
                     Option('detritus', help='Delete conflict files, merge and revert'
5971
6316
                            ' backups, and failed selftest dirs.'),
5972
6317
                     Option('unknown',
5973
6318
                            help='Delete files unknown to bzr (default).'),
5975
6320
                            ' deleting them.'),
5976
6321
                     Option('force', help='Do not prompt before deleting.')]
5977
6322
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
5978
 
            force=False):
 
6323
            force=False, directory=u'.'):
5979
6324
        from bzrlib.clean_tree import clean_tree
5980
6325
        if not (unknown or ignored or detritus):
5981
6326
            unknown = True
5982
6327
        if dry_run:
5983
6328
            force = True
5984
 
        clean_tree('.', unknown=unknown, ignored=ignored, detritus=detritus,
5985
 
                   dry_run=dry_run, no_prompt=force)
 
6329
        clean_tree(directory, unknown=unknown, ignored=ignored,
 
6330
                   detritus=detritus, dry_run=dry_run, no_prompt=force)
5986
6331
 
5987
6332
 
5988
6333
class cmd_reference(Command):
6032
6377
            self.outf.write('%s %s\n' % (path, location))
6033
6378
 
6034
6379
 
 
6380
class cmd_export_pot(Command):
 
6381
    __doc__ = """Export command helps and error messages in po format."""
 
6382
 
 
6383
    hidden = True
 
6384
 
 
6385
    def run(self):
 
6386
        from bzrlib.export_pot import export_pot
 
6387
        export_pot(self.outf)
 
6388
 
 
6389
 
6035
6390
def _register_lazy_builtins():
6036
6391
    # register lazy builtins from other modules; called at startup and should
6037
6392
    # be only called once.
6038
6393
    for (name, aliases, module_name) in [
6039
6394
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
 
6395
        ('cmd_config', [], 'bzrlib.config'),
6040
6396
        ('cmd_dpush', [], 'bzrlib.foreign'),
6041
6397
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6042
6398
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6043
6399
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6044
 
        ('cmd_sign_my_commits', [], 'bzrlib.sign_my_commits'),
 
6400
        ('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
 
6401
        ('cmd_verify_signatures', [],
 
6402
                                        'bzrlib.commit_signature_commands'),
 
6403
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
6045
6404
        ]:
6046
6405
        builtin_command_registry.register_lazy(name, aliases, module_name)