/breezy/unstable

To get this branch, use:
bzr branch https://code.breezy-vcs.org/breezy/unstable

« back to all changes in this revision

Viewing changes to breezy/builtins.py

  • Committer: Jelmer Vernooij
  • Date: 2017-05-24 01:39:33 UTC
  • mfrom: (3815.3776.6)
  • Revision ID: jelmer@jelmer.uk-20170524013933-ir4y4tqtrsiz2ka2
New upstream snapshot.

Show diffs side-by-side

added added

removed removed

Lines of Context:
14
14
# along with this program; if not, write to the Free Software
15
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
16
 
17
 
"""builtin bzr commands"""
 
17
"""builtin brz commands"""
18
18
 
19
19
from __future__ import absolute_import
20
20
 
 
21
import errno
21
22
import os
22
 
 
23
 
import bzrlib.bzrdir
24
 
 
25
 
from bzrlib import lazy_import
 
23
import sys
 
24
 
 
25
import breezy.bzrdir
 
26
 
 
27
from . import lazy_import
26
28
lazy_import.lazy_import(globals(), """
27
 
import cStringIO
28
 
import errno
29
 
import sys
30
29
import time
31
30
 
32
 
import bzrlib
33
 
from bzrlib import (
 
31
import breezy
 
32
from breezy import (
34
33
    bugtracker,
35
34
    bundle,
36
35
    btree_index,
56
55
    views,
57
56
    gpg,
58
57
    )
59
 
from bzrlib.branch import Branch
60
 
from bzrlib.conflicts import ConflictList
61
 
from bzrlib.transport import memory
62
 
from bzrlib.revisionspec import RevisionSpec, RevisionInfo
63
 
from bzrlib.smtp_connection import SMTPConnection
64
 
from bzrlib.workingtree import WorkingTree
65
 
from bzrlib.i18n import gettext, ngettext
 
58
from breezy.branch import Branch
 
59
from breezy.conflicts import ConflictList
 
60
from breezy.transport import memory
 
61
from breezy.revisionspec import RevisionSpec, RevisionInfo
 
62
from breezy.smtp_connection import SMTPConnection
 
63
from breezy.workingtree import WorkingTree
 
64
from breezy.i18n import gettext, ngettext
66
65
""")
67
66
 
68
 
from bzrlib.commands import (
 
67
from .commands import (
69
68
    Command,
70
69
    builtin_command_registry,
71
70
    display_command,
72
71
    )
73
 
from bzrlib.option import (
 
72
from .option import (
74
73
    ListOption,
75
74
    Option,
76
75
    RegistryOption,
77
76
    custom_help,
78
77
    _parse_revision_str,
79
78
    )
80
 
from bzrlib.trace import mutter, note, warning, is_quiet, get_verbosity_level
81
 
from bzrlib import (
 
79
from .sixish import (
 
80
    BytesIO,
 
81
    text_type,
 
82
)
 
83
from .trace import mutter, note, warning, is_quiet, get_verbosity_level
 
84
from . import (
82
85
    symbol_versioning,
83
86
    )
84
87
 
257
260
        return None
258
261
    if len(revisions) != 1:
259
262
        raise errors.BzrCommandError(gettext(
260
 
            'bzr %s --revision takes exactly one revision identifier') % (
 
263
            'brz %s --revision takes exactly one revision identifier') % (
261
264
                command_name,))
262
265
    return revisions[0]
263
266
 
343
346
    character: '/', '@' or '*' respectively. These decorations can be
344
347
    disabled using the '--no-classify' option.
345
348
 
346
 
    To see ignored files use 'bzr ignored'.  For details on the
347
 
    changes to file texts, use 'bzr diff'.
 
349
    To see ignored files use 'brz ignored'.  For details on the
 
350
    changes to file texts, use 'brz diff'.
348
351
 
349
352
    Note that --short or -S gives status flags for each item, similar
350
353
    to Subversion's status command. To get output similar to svn -q,
351
 
    use bzr status -SV.
 
354
    use brz status -SV.
352
355
 
353
356
    If no arguments are specified, the status of the entire working
354
357
    directory is shown.  Otherwise, only the status of the specified
365
368
 
366
369
    To see which files have changed in a specific revision, or between
367
370
    two revisions, pass a revision range to the revision argument.
368
 
    This will produce the same results as calling 'bzr diff --summarize'.
 
371
    This will produce the same results as calling 'brz diff --summarize'.
369
372
    """
370
373
 
371
374
    # TODO: --no-recurse/-N, --recurse options
391
394
    def run(self, show_ids=False, file_list=None, revision=None, short=False,
392
395
            versioned=False, no_pending=False, verbose=False,
393
396
            no_classify=False):
394
 
        from bzrlib.status import show_tree_status
 
397
        from .status import show_tree_status
395
398
 
396
399
        if revision and len(revision) > 2:
397
 
            raise errors.BzrCommandError(gettext('bzr status --revision takes exactly'
 
400
            raise errors.BzrCommandError(gettext('brz status --revision takes exactly'
398
401
                                         ' one or two revision specifiers'))
399
402
 
400
403
        tree, relfile_list = WorkingTree.open_containing_paths(file_list)
507
510
        """Create a BTreeGraphIndex and raw bytes."""
508
511
        bt = btree_index.BTreeGraphIndex(trans, basename, None)
509
512
        bytes = trans.get_bytes(basename)
510
 
        bt._file = cStringIO.StringIO(bytes)
 
513
        bt._file = BytesIO(bytes)
511
514
        bt._size = len(bytes)
512
515
        return bt, bytes
513
516
 
563
566
    Since a lightweight checkout is little more than a working tree
564
567
    this will refuse to run against one.
565
568
 
566
 
    To re-create the working tree, use "bzr checkout".
 
569
    To re-create the working tree, use "brz checkout".
567
570
    """
568
571
    _see_also = ['checkout', 'working-trees']
569
572
    takes_args = ['location*']
608
611
    'known good' state. Any new modifications (adding a file, renaming, etc)
609
612
    will be lost, though modified files will still be detected as such.
610
613
 
611
 
    Most users will want something more like "bzr revert" or "bzr update"
 
614
    Most users will want something more like "brz revert" or "brz update"
612
615
    unless the state file has become corrupted.
613
616
 
614
617
    By default this attempts to recover the current state by looking at the
635
638
                # Refuse
636
639
                raise errors.BzrCommandError(gettext(
637
640
                    'The tree does not appear to be corrupt. You probably'
638
 
                    ' want "bzr revert" instead. Use "--force" if you are'
 
641
                    ' want "brz revert" instead. Use "--force" if you are'
639
642
                    ' sure you want to reset the working tree.'))
640
643
        if revision is None:
641
644
            revision_ids = None
643
646
            revision_ids = [r.as_revision_id(tree.branch) for r in revision]
644
647
        try:
645
648
            tree.reset_state(revision_ids)
646
 
        except errors.BzrError, e:
 
649
        except errors.BzrError as e:
647
650
            if revision_ids is None:
648
651
                extra = (gettext(', the header appears corrupt, try passing -r -1'
649
652
                         ' to set the state to the last commit'))
774
777
    A warning will be printed when nested trees are encountered,
775
778
    unless they are explicitly ignored.
776
779
 
777
 
    Therefore simply saying 'bzr add' will version all files that
 
780
    Therefore simply saying 'brz add' will version all files that
778
781
    are currently unknown.
779
782
 
780
783
    Adding a file whose parent directory is not versioned will
809
812
               help="Show what would be done, but don't actually do anything."),
810
813
        'verbose',
811
814
        Option('file-ids-from',
812
 
               type=unicode,
 
815
               type=text_type,
813
816
               help='Lookup file ids from this tree.'),
814
817
        ]
815
818
    encoding_type = 'replace'
817
820
 
818
821
    def run(self, file_list, no_recurse=False, dry_run=False, verbose=False,
819
822
            file_ids_from=None):
820
 
        import bzrlib.add
 
823
        import breezy.add
821
824
 
822
825
        base_tree = None
823
826
        if file_ids_from is not None:
829
832
                                            file_ids_from)
830
833
                base_tree = base_branch.basis_tree()
831
834
 
832
 
            action = bzrlib.add.AddFromBaseAction(base_tree, base_path,
 
835
            action = breezy.add.AddFromBaseAction(base_tree, base_path,
833
836
                          to_file=self.outf, should_print=(not is_quiet()))
834
837
        else:
835
 
            action = bzrlib.add.AddWithSkipLargeAction(to_file=self.outf,
 
838
            action = breezy.add.AddWithSkipLargeAction(to_file=self.outf,
836
839
                should_print=(not is_quiet()))
837
840
 
838
841
        if base_tree:
887
890
            if parents:
888
891
                try:
889
892
                    os.makedirs(dir)
890
 
                except OSError, e:
 
893
                except OSError as e:
891
894
                    if e.errno != errno.EEXIST:
892
895
                        raise
893
896
            else:
919
922
    type using the --kind option.  For example: --kind file.
920
923
 
921
924
    It is also possible to restrict the list of files to a specific
922
 
    set. For example: bzr inventory --show-ids this/file
 
925
    set. For example: brz inventory --show-ids this/file
923
926
    """
924
927
 
925
928
    hidden = True
929
932
        'show-ids',
930
933
        Option('kind',
931
934
               help='List entries of a particular kind: file, directory, symlink.',
932
 
               type=unicode),
 
935
               type=text_type),
933
936
        ]
934
937
    takes_args = ['file*']
935
938
 
976
979
    __doc__ = """Move or rename a file.
977
980
 
978
981
    :Usage:
979
 
        bzr mv OLDNAME NEWNAME
 
982
        brz mv OLDNAME NEWNAME
980
983
 
981
 
        bzr mv SOURCE... DESTINATION
 
984
        brz mv SOURCE... DESTINATION
982
985
 
983
986
    If the last argument is a versioned directory, all the other names
984
987
    are moved into it.  Otherwise, there must be exactly two arguments
994
997
    """
995
998
 
996
999
    takes_args = ['names*']
997
 
    takes_options = [Option("after", help="Move only the bzr identifier"
 
1000
    takes_options = [Option("after", help="Move only the brz identifier"
998
1001
        " of the file, because the file has already been moved."),
999
1002
        Option('auto', help='Automatically guess renames.'),
1000
1003
        Option('dry-run', help='Avoid making changes when guessing renames.'),
1118
1121
    commit is one that has not been merged (directly or indirectly) into the 
1119
1122
    parent.
1120
1123
 
1121
 
    If branches have diverged, you can use 'bzr merge' to integrate the changes
 
1124
    If branches have diverged, you can use 'brz merge' to integrate the changes
1122
1125
    from one into the other.  Once one branch has merged, the other should
1123
1126
    be able to pull it again.
1124
1127
 
1137
1140
 
1138
1141
    Note: The location can be specified either in the form of a branch,
1139
1142
    or in the form of a path to a file containing a merge directive generated
1140
 
    with bzr send.
 
1143
    with brz send.
1141
1144
    """
1142
1145
 
1143
1146
    _see_also = ['push', 'update', 'status-flags', 'send']
1269
1272
    considered diverged if the destination branch's most recent commit is one
1270
1273
    that has not been merged (directly or indirectly) by the source branch.
1271
1274
 
1272
 
    If branches have diverged, you can use 'bzr push --overwrite' to replace
 
1275
    If branches have diverged, you can use 'brz push --overwrite' to replace
1273
1276
    the other branch completely, discarding its unmerged changes.
1274
1277
 
1275
1278
    If you want to ensure you have the different changes in the other branch,
1276
 
    do a merge (see bzr help merge) from the other branch, and commit that.
 
1279
    do a merge (see brz help merge) from the other branch, and commit that.
1277
1280
    After that you will be able to do a push without '--overwrite'.
1278
1281
 
1279
1282
    If there is no default push location set, the first push will set it (use
1306
1309
            help='Create a stacked branch that refers to another branch '
1307
1310
                'for the commit history. Only the work not present in the '
1308
1311
                'referenced branch is included in the branch created.',
1309
 
            type=unicode),
 
1312
            type=text_type),
1310
1313
        Option('strict',
1311
1314
               help='Refuse to push if there are uncommitted changes in'
1312
1315
               ' the working tree, --no-strict disables the check.'),
1324
1327
        use_existing_dir=False, directory=None, stacked_on=None,
1325
1328
        stacked=False, strict=None, no_tree=False,
1326
1329
        overwrite_tags=False):
1327
 
        from bzrlib.push import _show_push_branch
 
1330
        from .push import _show_push_branch
1328
1331
 
1329
1332
        if overwrite:
1330
1333
            overwrite = ["history", "tags"]
1375
1378
                if parent_loc:
1376
1379
                    raise errors.BzrCommandError(gettext(
1377
1380
                        "No push location known or specified. To push to the "
1378
 
                        "parent branch (at %s), use 'bzr push :parent'." %
 
1381
                        "parent branch (at %s), use 'brz push :parent'." %
1379
1382
                        urlutils.unescape_for_display(parent_loc,
1380
1383
                            self.outf.encoding)))
1381
1384
                else:
1440
1443
            hardlink=False, stacked=False, standalone=False, no_tree=False,
1441
1444
            use_existing_dir=False, switch=False, bind=False,
1442
1445
            files_from=None):
1443
 
        from bzrlib import switch as _mod_switch
1444
 
        from bzrlib.tag import _merge_tags_if_possible
 
1446
        from breezy import switch as _mod_switch
 
1447
        from .tag import _merge_tags_if_possible
1445
1448
        if self.invoked_as in ['get', 'clone']:
1446
1449
            ui.ui_factory.show_user_warning(
1447
1450
                'deprecated_command',
1528
1531
            note(gettext('Created new stacked branch referring to %s.') %
1529
1532
                branch.get_stacked_on_url())
1530
1533
        except (errors.NotStacked, errors.UnstackableBranchFormat,
1531
 
            errors.UnstackableRepositoryFormat), e:
 
1534
            errors.UnstackableRepositoryFormat) as e:
1532
1535
            note(ngettext('Branched %d revision.', 'Branched %d revisions.', branch.revno()) % branch.revno())
1533
1536
        if bind:
1534
1537
            # Bind to the parent
1707
1710
    
1708
1711
    If there are any uncommitted changes in the tree, they will be carried
1709
1712
    across and remain as uncommitted changes after the update.  To discard
1710
 
    these changes, use 'bzr revert'.  The uncommitted changes may conflict
 
1713
    these changes, use 'brz revert'.  The uncommitted changes may conflict
1711
1714
    with the changes brought in by the change in basis revision.
1712
1715
 
1713
 
    If the tree's branch is bound to a master branch, bzr will also update
 
1716
    If the tree's branch is bound to a master branch, brz will also update
1714
1717
    the branch from the master.
1715
1718
 
1716
1719
    You cannot update just a single file or directory, because each Bazaar
1717
1720
    working tree has just a single basis revision.  If you want to restore a
1718
 
    file that has been removed locally, use 'bzr revert' instead of 'bzr
 
1721
    file that has been removed locally, use 'brz revert' instead of 'brz
1719
1722
    update'.  If you want to restore a file to its state in a previous
1720
 
    revision, use 'bzr revert' with a '-r' option, or use 'bzr cat' to write
 
1723
    revision, use 'brz revert' with a '-r' option, or use 'brz cat' to write
1721
1724
    out the old content of that file to a new location.
1722
1725
 
1723
1726
    The 'dir' argument, if given, must be the location of the root of a
1735
1738
 
1736
1739
    def run(self, dir=None, revision=None, show_base=None):
1737
1740
        if revision is not None and len(revision) != 1:
1738
 
            raise errors.BzrCommandError(gettext(
1739
 
                "bzr update --revision takes exactly one revision"))
 
1741
            raise errors.brzCommandError(gettext(
 
1742
                "brz update --revision takes exactly one revision"))
1740
1743
        if dir is None:
1741
1744
            tree = WorkingTree.open_containing('.')[0]
1742
1745
        else:
1744
1747
            if relpath:
1745
1748
                # See bug 557886.
1746
1749
                raise errors.BzrCommandError(gettext(
1747
 
                    "bzr update can only update a whole tree, "
 
1750
                    "brz update can only update a whole tree, "
1748
1751
                    "not a file or subdirectory"))
1749
1752
        branch = tree.branch
1750
1753
        possible_transports = []
1789
1792
                revision=revision_id,
1790
1793
                old_tip=old_tip,
1791
1794
                show_base=show_base)
1792
 
        except errors.NoSuchRevision, e:
 
1795
        except errors.NoSuchRevision as e:
1793
1796
            raise errors.BzrCommandError(gettext(
1794
1797
                                  "branch has no revision %s\n"
1795
 
                                  "bzr update --revision only works"
 
1798
                                  "brz update --revision only works"
1796
1799
                                  " for a revision in the branch history")
1797
1800
                                  % (e.revision))
1798
1801
        revno = tree.branch.revision_id_to_dotted_revno(
1802
1805
        parent_ids = tree.get_parent_ids()
1803
1806
        if parent_ids[1:] and parent_ids[1:] != existing_pending_merges:
1804
1807
            note(gettext('Your local commits will now show as pending merges with '
1805
 
                 "'bzr status', and can be committed with 'bzr commit'."))
 
1808
                 "'brz status', and can be committed with 'brz commit'."))
1806
1809
        if conflicts != 0:
1807
1810
            return 1
1808
1811
        else:
1825
1828
 
1826
1829
      Display information on the format and related locations:
1827
1830
 
1828
 
        bzr info
 
1831
        brz info
1829
1832
 
1830
1833
      Display the above together with extended format information and
1831
1834
      basic statistics (like the number of files in the working tree and
1832
1835
      number of revisions in the branch and repository):
1833
1836
 
1834
 
        bzr info -v
 
1837
        brz info -v
1835
1838
 
1836
1839
      Display the above together with number of committers to the branch:
1837
1840
 
1838
 
        bzr info -vv
 
1841
        brz info -vv
1839
1842
    """
1840
1843
    _see_also = ['revno', 'working-trees', 'repositories']
1841
1844
    takes_args = ['location?']
1848
1851
            noise_level = get_verbosity_level()
1849
1852
        else:
1850
1853
            noise_level = 0
1851
 
        from bzrlib.info import show_bzrdir_info
 
1854
        from .info import show_bzrdir_info
1852
1855
        show_bzrdir_info(controldir.ControlDir.open_containing(location)[0],
1853
1856
                         verbose=noise_level, outfile=self.outf)
1854
1857
 
1869
1872
            'The file deletion mode to be used.',
1870
1873
            title='Deletion Strategy', value_switches=True, enum_switch=False,
1871
1874
            safe='Backup changed files (default).',
1872
 
            keep='Delete from bzr but leave the working copy.',
 
1875
            keep='Delete from brz but leave the working copy.',
1873
1876
            no_backup='Don\'t backup changed files.'),
1874
1877
        ]
1875
1878
    aliases = ['rm', 'del']
1952
1955
 
1953
1956
 
1954
1957
class cmd_reconcile(Command):
1955
 
    __doc__ = """Reconcile bzr metadata in a branch.
 
1958
    __doc__ = """Reconcile brz metadata in a branch.
1956
1959
 
1957
1960
    This can correct data mismatches that may have been caused by
1958
 
    previous ghost operations or bzr upgrades. You should only
1959
 
    need to run this command if 'bzr check' or a bzr developer
 
1961
    previous ghost operations or brz upgrades. You should only
 
1962
    need to run this command if 'brz check' or a brz developer
1960
1963
    advises you to run it.
1961
1964
 
1962
1965
    If a second branch is provided, cross-branch reconciliation is
1963
1966
    also attempted, which will check that data like the tree root
1964
 
    id which was not present in very early bzr versions is represented
 
1967
    id which was not present in very early brz versions is represented
1965
1968
    correctly in both branches.
1966
1969
 
1967
1970
    At the same time it is run it may recompress data resulting in
1980
1983
        ]
1981
1984
 
1982
1985
    def run(self, branch=".", canonicalize_chks=False):
1983
 
        from bzrlib.reconcile import reconcile
 
1986
        from .reconcile import reconcile
1984
1987
        dir = controldir.ControlDir.open(branch)
1985
1988
        reconcile(dir, canonicalize_chks=canonicalize_chks)
1986
1989
 
2046
2049
    in the .bzr directory.
2047
2050
 
2048
2051
    If there is already a branch at the location but it has no working tree,
2049
 
    the tree can be populated with 'bzr checkout'.
 
2052
    the tree can be populated with 'brz checkout'.
2050
2053
 
2051
2054
    Recipe for importing a tree of files::
2052
2055
 
2053
2056
        cd ~/project
2054
 
        bzr init
2055
 
        bzr add .
2056
 
        bzr status
2057
 
        bzr commit -m "imported project"
 
2057
        brz init
 
2058
        brz add .
 
2059
        brz status
 
2060
        brz commit -m "imported project"
2058
2061
    """
2059
2062
 
2060
2063
    _see_also = ['init-repository', 'branch', 'checkout']
2066
2069
         RegistryOption('format',
2067
2070
                help='Specify a format for this branch. '
2068
2071
                'See "help formats".',
2069
 
                lazy_registry=('bzrlib.controldir', 'format_registry'),
 
2072
                lazy_registry=('breezy.controldir', 'format_registry'),
2070
2073
                converter=lambda name: controldir.format_registry.make_bzrdir(name),
2071
2074
                value_switches=True,
2072
2075
                title="Branch format",
2116
2119
                                   force_new_tree=force_new_tree)
2117
2120
            a_bzrdir = branch.bzrdir
2118
2121
        else:
2119
 
            from bzrlib.transport.local import LocalTransport
 
2122
            from .transport.local import LocalTransport
2120
2123
            if a_bzrdir.has_branch():
2121
2124
                if (isinstance(to_transport, LocalTransport)
2122
2125
                    and not a_bzrdir.has_workingtree()):
2132
2135
                raise errors.BzrCommandError(gettext('This branch format cannot be set'
2133
2136
                    ' to append-revisions-only.  Try --default.'))
2134
2137
        if not is_quiet():
2135
 
            from bzrlib.info import describe_layout, describe_format
 
2138
            from .info import describe_layout, describe_format
2136
2139
            try:
2137
2140
                tree = a_bzrdir.open_workingtree(recommend_upgrade=False)
2138
2141
            except (errors.NoWorkingTree, errors.NotLocalUrl):
2170
2173
    :Examples:
2171
2174
        Create a shared repository holding just branches::
2172
2175
 
2173
 
            bzr init-repo --no-trees repo
2174
 
            bzr init repo/trunk
 
2176
            brz init-repo --no-trees repo
 
2177
            brz init repo/trunk
2175
2178
 
2176
2179
        Make a lightweight checkout elsewhere::
2177
2180
 
2178
 
            bzr checkout --lightweight repo/trunk trunk-checkout
 
2181
            brz checkout --lightweight repo/trunk trunk-checkout
2179
2182
            cd trunk-checkout
2180
2183
            (add files here)
2181
2184
    """
2184
2187
    takes_args = ["location"]
2185
2188
    takes_options = [RegistryOption('format',
2186
2189
                            help='Specify a format for this repository. See'
2187
 
                                 ' "bzr help formats" for details.',
2188
 
                            lazy_registry=('bzrlib.controldir', 'format_registry'),
 
2190
                                 ' "brz help formats" for details.',
 
2191
                            lazy_registry=('breezy.controldir', 'format_registry'),
2189
2192
                            converter=lambda name: controldir.format_registry.make_bzrdir(name),
2190
2193
                            value_switches=True, title='Repository format'),
2191
2194
                     Option('no-trees',
2210
2213
            use_existing_dir=True,
2211
2214
            repo_format_name=format.repository_format.get_format_string()))
2212
2215
        if not is_quiet():
2213
 
            from bzrlib.info import show_bzrdir_info
 
2216
            from .info import show_bzrdir_info
2214
2217
            show_bzrdir_info(newdir, verbose=0, outfile=self.outf)
2215
2218
 
2216
2219
 
2224
2227
    the first argument, if any, or the current tree if no arguments are
2225
2228
    given.
2226
2229
 
2227
 
    "bzr diff -p1" is equivalent to "bzr diff --prefix old/:new/", and
 
2230
    "brz diff -p1" is equivalent to "brz diff --prefix old/:new/", and
2228
2231
    produces patches suitable for "patch -p1".
2229
2232
 
2230
2233
    Note that when using the -r argument with a range of revisions, the
2231
2234
    differences are computed between the two specified revisions.  That
2232
2235
    is, the command does not show the changes introduced by the first 
2233
2236
    revision in the range.  This differs from the interpretation of 
2234
 
    revision ranges used by "bzr log" which includes the first revision
 
2237
    revision ranges used by "brz log" which includes the first revision
2235
2238
    in the range.
2236
2239
 
2237
2240
    :Exit values:
2243
2246
    :Examples:
2244
2247
        Shows the difference in the working tree versus the last commit::
2245
2248
 
2246
 
            bzr diff
 
2249
            brz diff
2247
2250
 
2248
2251
        Difference between the working tree and revision 1::
2249
2252
 
2250
 
            bzr diff -r1
 
2253
            brz diff -r1
2251
2254
 
2252
2255
        Difference between revision 3 and revision 1::
2253
2256
 
2254
 
            bzr diff -r1..3
 
2257
            brz diff -r1..3
2255
2258
 
2256
2259
        Difference between revision 3 and revision 1 for branch xxx::
2257
2260
 
2258
 
            bzr diff -r1..3 xxx
 
2261
            brz diff -r1..3 xxx
2259
2262
 
2260
2263
        The changes introduced by revision 2 (equivalent to -r1..2)::
2261
2264
 
2262
 
            bzr diff -c2
 
2265
            brz diff -c2
2263
2266
 
2264
2267
        To see the changes introduced by revision X::
2265
2268
        
2266
 
            bzr diff -cX
 
2269
            brz diff -cX
2267
2270
 
2268
2271
        Note that in the case of a merge, the -c option shows the changes
2269
2272
        compared to the left hand parent. To see the changes against
2270
2273
        another parent, use::
2271
2274
 
2272
 
            bzr diff -r<chosen_parent>..X
 
2275
            brz diff -r<chosen_parent>..X
2273
2276
 
2274
2277
        The changes between the current revision and the previous revision
2275
2278
        (equivalent to -c-1 and -r-2..-1)
2276
2279
 
2277
 
            bzr diff -r-2..
 
2280
            brz diff -r-2..
2278
2281
 
2279
2282
        Show just the differences for file NEWS::
2280
2283
 
2281
 
            bzr diff NEWS
 
2284
            brz diff NEWS
2282
2285
 
2283
2286
        Show the differences in working tree xxx for file NEWS::
2284
2287
 
2285
 
            bzr diff xxx/NEWS
 
2288
            brz diff xxx/NEWS
2286
2289
 
2287
2290
        Show the differences from branch xxx to this working tree:
2288
2291
 
2289
 
            bzr diff --old xxx
 
2292
            brz diff --old xxx
2290
2293
 
2291
2294
        Show the differences between two branches for file NEWS::
2292
2295
 
2293
 
            bzr diff --old xxx --new yyy NEWS
2294
 
 
2295
 
        Same as 'bzr diff' but prefix paths with old/ and new/::
2296
 
 
2297
 
            bzr diff --prefix old/:new/
 
2296
            brz diff --old xxx --new yyy NEWS
 
2297
 
 
2298
        Same as 'brz diff' but prefix paths with old/ and new/::
 
2299
 
 
2300
            brz diff --prefix old/:new/
2298
2301
            
2299
2302
        Show the differences using a custom diff program with options::
2300
2303
        
2301
 
            bzr diff --using /usr/bin/diff --diff-options -wu
 
2304
            brz diff --using /usr/bin/diff --diff-options -wu
2302
2305
    """
2303
2306
    _see_also = ['status']
2304
2307
    takes_args = ['file*']
2311
2314
                    'two values separated by a colon. (eg "old/:new/").'),
2312
2315
        Option('old',
2313
2316
            help='Branch/tree to compare from.',
2314
 
            type=unicode,
 
2317
            type=text_type,
2315
2318
            ),
2316
2319
        Option('new',
2317
2320
            help='Branch/tree to compare to.',
2318
 
            type=unicode,
 
2321
            type=text_type,
2319
2322
            ),
2320
2323
        'revision',
2321
2324
        'change',
2322
2325
        Option('using',
2323
2326
            help='Use this command to compare files.',
2324
 
            type=unicode,
 
2327
            type=text_type,
2325
2328
            ),
2326
2329
        RegistryOption('format',
2327
2330
            short_name='F',
2328
2331
            help='Diff format to use.',
2329
 
            lazy_registry=('bzrlib.diff', 'format_registry'),
 
2332
            lazy_registry=('breezy.diff', 'format_registry'),
2330
2333
            title='Diff format'),
2331
2334
        Option('context',
2332
2335
            help='How many lines of context to show.',
2340
2343
    def run(self, revision=None, file_list=None, diff_options=None,
2341
2344
            prefix=None, old=None, new=None, using=None, format=None, 
2342
2345
            context=None):
2343
 
        from bzrlib.diff import (get_trees_and_branches_to_diff_locked,
 
2346
        from .diff import (get_trees_and_branches_to_diff_locked,
2344
2347
            show_diff_trees)
2345
2348
 
2346
2349
        if (prefix is None) or (prefix == '0'):
2358
2361
                ' (eg "old/:new/")'))
2359
2362
 
2360
2363
        if revision and len(revision) > 2:
2361
 
            raise errors.BzrCommandError(gettext('bzr diff --revision takes exactly'
 
2364
            raise errors.BzrCommandError(gettext('brz diff --revision takes exactly'
2362
2365
                                         ' one or two revision specifiers'))
2363
2366
 
2364
2367
        if using is not None and format is not None:
2492
2495
class cmd_log(Command):
2493
2496
    __doc__ = """Show historical log for a branch or subset of a branch.
2494
2497
 
2495
 
    log is bzr's default tool for exploring the history of a branch.
 
2498
    log is brz's default tool for exploring the history of a branch.
2496
2499
    The branch to use is taken from the first parameter. If no parameters
2497
2500
    are given, the branch containing the working directory is logged.
2498
2501
    Here are some simple examples::
2499
2502
 
2500
 
      bzr log                       log the current branch
2501
 
      bzr log foo.py                log a file in its branch
2502
 
      bzr log http://server/branch  log a branch on a server
 
2503
      brz log                       log the current branch
 
2504
      brz log foo.py                log a file in its branch
 
2505
      brz log http://server/branch  log a branch on a server
2503
2506
 
2504
2507
    The filtering, ordering and information shown for each revision can
2505
2508
    be controlled as explained below. By default, all revisions are
2512
2515
 
2513
2516
      The log format controls how information about each revision is
2514
2517
      displayed. The standard log formats are called ``long``, ``short``
2515
 
      and ``line``. The default is long. See ``bzr help log-formats``
 
2518
      and ``line``. The default is long. See ``brz help log-formats``
2516
2519
      for more details on log formats.
2517
2520
 
2518
2521
      The following options can be used to control what information is
2549
2552
        -r..Y    display up to and including revision Y
2550
2553
        -rX..Y   display from X to Y inclusive
2551
2554
 
2552
 
      See ``bzr help revisionspec`` for details on how to specify X and Y.
 
2555
      See ``brz help revisionspec`` for details on how to specify X and Y.
2553
2556
      Some common examples are given below::
2554
2557
 
2555
2558
        -r-1                show just the tip
2585
2588
 
2586
2589
      In this case:
2587
2590
 
2588
 
      * ``bzr log guide.txt`` will log the file added in revision 1
2589
 
 
2590
 
      * ``bzr log tutorial.txt`` will log the new file added in revision 3
2591
 
 
2592
 
      * ``bzr log -r2 -p tutorial.txt`` will show the changes made to
 
2591
      * ``brz log guide.txt`` will log the file added in revision 1
 
2592
 
 
2593
      * ``brz log tutorial.txt`` will log the new file added in revision 3
 
2594
 
 
2595
      * ``brz log -r2 -p tutorial.txt`` will show the changes made to
2593
2596
        the original file in revision 2.
2594
2597
 
2595
 
      * ``bzr log -r2 -p guide.txt`` will display an error message as there
 
2598
      * ``brz log -r2 -p guide.txt`` will display an error message as there
2596
2599
        was no file called guide.txt in revision 2.
2597
2600
 
2598
2601
      Renames are always followed by log. By design, there is no need to
2611
2614
 
2612
2615
      GUI tools and IDEs are often better at exploring history than command
2613
2616
      line tools: you may prefer qlog or viz from qbzr or bzr-gtk, the
2614
 
      bzr-explorer shell, or the Loggerhead web interface.  See the Plugin
2615
 
      Guide <http://doc.bazaar.canonical.com/plugins/en/> and
 
2617
      bzr-explorer shell, or the Loggerhead web interface.  See the Bazaar
 
2618
      Plugin Guide <http://doc.bazaar.canonical.com/plugins/en/> and
2616
2619
      <http://wiki.bazaar.canonical.com/IDEIntegration>.  
2617
2620
 
2618
2621
      You may find it useful to add the aliases below to ``bazaar.conf``::
2622
2625
        top = log -l10 --line
2623
2626
        show = log -v -p
2624
2627
 
2625
 
      ``bzr tip`` will then show the latest revision while ``bzr top``
 
2628
      ``brz tip`` will then show the latest revision while ``brz top``
2626
2629
      will show the last 10 mainline revisions. To see the details of a
2627
 
      particular revision X,  ``bzr show -rX``.
 
2630
      particular revision X,  ``brz show -rX``.
2628
2631
 
2629
2632
      If you are interested in looking deeper into a particular merge X,
2630
 
      use ``bzr log -n0 -rX``.
 
2633
      use ``brz log -n0 -rX``.
2631
2634
 
2632
 
      ``bzr log -v`` on a branch with lots of history is currently
 
2635
      ``brz log -v`` on a branch with lots of history is currently
2633
2636
      very slow. A fix for this issue is currently under development.
2634
2637
      With or without that fix, it is recommended that a revision range
2635
2638
      be given when using the -v option.
2636
2639
 
2637
 
      bzr has a generic full-text matching plugin, bzr-search, that can be
 
2640
      brz has a generic full-text matching plugin, brz-search, that can be
2638
2641
      used to find revisions matching user names, commit messages, etc.
2639
2642
      Among other features, this plugin can find all revisions containing
2640
2643
      a list of words but not others.
2655
2658
            'show-ids',
2656
2659
            'revision',
2657
2660
            Option('change',
2658
 
                   type=bzrlib.option._parse_revision_str,
 
2661
                   type=breezy.option._parse_revision_str,
2659
2662
                   short_name='c',
2660
2663
                   help='Show just the specified revision.'
2661
2664
                   ' See also "help revisionspec".'),
2663
2666
            RegistryOption('authors',
2664
2667
                'What names to list as authors - first, all or committer.',
2665
2668
                title='Authors',
2666
 
                lazy_registry=('bzrlib.log', 'author_list_registry'),
 
2669
                lazy_registry=('breezy.log', 'author_list_registry'),
2667
2670
            ),
2668
2671
            Option('levels',
2669
2672
                   short_name='n',
2743
2746
            omit_merges=False,
2744
2747
            include_merges=symbol_versioning.DEPRECATED_PARAMETER,
2745
2748
            ):
2746
 
        from bzrlib.log import (
 
2749
        from .log import (
2747
2750
            Logger,
2748
2751
            make_log_request_dict,
2749
2752
            _get_info_for_log_files,
2912
2915
            # show_log will use its revision_history. Having
2913
2916
            # different branches will lead to weird behaviors.
2914
2917
            raise errors.BzrCommandError(gettext(
2915
 
                "bzr %s doesn't accept two revisions in different"
 
2918
                "brz %s doesn't accept two revisions in different"
2916
2919
                " branches.") % command_name)
2917
2920
        if start_spec.spec is None:
2918
2921
            # Avoid loading all the history.
2928
2931
            rev2 = end_spec.in_history(branch)
2929
2932
    else:
2930
2933
        raise errors.BzrCommandError(gettext(
2931
 
            'bzr %s --revision takes one or two values.') % command_name)
 
2934
            'brz %s --revision takes one or two values.') % command_name)
2932
2935
    return rev1, rev2
2933
2936
 
2934
2937
 
2955
2958
class cmd_touching_revisions(Command):
2956
2959
    __doc__ = """Return revision-ids which affected a particular file.
2957
2960
 
2958
 
    A more user-friendly interface is "bzr log FILE".
 
2961
    A more user-friendly interface is "brz log FILE".
2959
2962
    """
2960
2963
 
2961
2964
    hidden = True
2993
2996
                help='Print ignored files.'),
2994
2997
            Option('kind', short_name='k',
2995
2998
                   help='List entries of a particular kind: file, directory, symlink.',
2996
 
                   type=unicode),
 
2999
                   type=text_type),
2997
3000
            'null',
2998
3001
            'show-ids',
2999
3002
            'directory',
3106
3109
class cmd_ignore(Command):
3107
3110
    __doc__ = """Ignore specified files or patterns.
3108
3111
 
3109
 
    See ``bzr help patterns`` for details on the syntax of patterns.
 
3112
    See ``brz help patterns`` for details on the syntax of patterns.
3110
3113
 
3111
3114
    If a .bzrignore file does not exist, the ignore command
3112
3115
    will create one and add the specified files or patterns to the newly
3143
3146
    :Examples:
3144
3147
        Ignore the top level Makefile::
3145
3148
 
3146
 
            bzr ignore ./Makefile
 
3149
            brz ignore ./Makefile
3147
3150
 
3148
3151
        Ignore .class files in all directories...::
3149
3152
 
3150
 
            bzr ignore "*.class"
 
3153
            brz ignore "*.class"
3151
3154
 
3152
3155
        ...but do not ignore "special.class"::
3153
3156
 
3154
 
            bzr ignore "!special.class"
 
3157
            brz ignore "!special.class"
3155
3158
 
3156
3159
        Ignore files whose name begins with the "#" character::
3157
3160
 
3158
 
            bzr ignore "RE:^#"
3159
 
 
3160
 
        Ignore .o files under the lib directory::
3161
 
 
3162
 
            bzr ignore "lib/**/*.o"
3163
 
 
3164
 
        Ignore .o files under the lib directory::
3165
 
 
3166
 
            bzr ignore "RE:lib/.*\.o"
 
3161
            brz ignore "RE:^#"
 
3162
 
 
3163
        Ignore .o files under the lib directory::
 
3164
 
 
3165
            brz ignore "lib/**/*.o"
 
3166
 
 
3167
        Ignore .o files under the lib directory::
 
3168
 
 
3169
            brz ignore "RE:lib/.*\.o"
3167
3170
 
3168
3171
        Ignore everything but the "debian" toplevel directory::
3169
3172
 
3170
 
            bzr ignore "RE:(?!debian/).*"
 
3173
            brz ignore "RE:(?!debian/).*"
3171
3174
        
3172
3175
        Ignore everything except the "local" toplevel directory,
3173
3176
        but always ignore autosave files ending in ~, even under local/::
3174
3177
        
3175
 
            bzr ignore "*"
3176
 
            bzr ignore "!./local"
3177
 
            bzr ignore "!!*~"
 
3178
            brz ignore "*"
 
3179
            brz ignore "!./local"
 
3180
            brz ignore "!!*~"
3178
3181
    """
3179
3182
 
3180
3183
    _see_also = ['status', 'ignored', 'patterns']
3181
3184
    takes_args = ['name_pattern*']
3182
3185
    takes_options = ['directory',
3183
3186
        Option('default-rules',
3184
 
               help='Display the default ignore rules that bzr uses.')
 
3187
               help='Display the default ignore rules that brz uses.')
3185
3188
        ]
3186
3189
 
3187
3190
    def run(self, name_pattern_list=None, default_rules=None,
3188
3191
            directory=u'.'):
3189
 
        from bzrlib import ignores
 
3192
        from breezy import ignores
3190
3193
        if default_rules is not None:
3191
3194
            # dump the default rules and exit
3192
3195
            for pattern in ignores.USER_DEFAULTS:
3229
3232
            self.outf.write(gettext("Warning: the following files are version "
3230
3233
                  "controlled and match your ignore pattern:\n%s"
3231
3234
                  "\nThese files will continue to be version controlled"
3232
 
                  " unless you 'bzr remove' them.\n") % ("\n".join(matches),))
 
3235
                  " unless you 'brz remove' them.\n") % ("\n".join(matches),))
3233
3236
 
3234
3237
 
3235
3238
class cmd_ignored(Command):
3240
3243
 
3241
3244
    Alternatively, to list just the files::
3242
3245
 
3243
 
        bzr ls --ignored
 
3246
        brz ls --ignored
3244
3247
    """
3245
3248
 
3246
3249
    encoding_type = 'replace'
3263
3266
    __doc__ = """Lookup the revision-id from a revision-number
3264
3267
 
3265
3268
    :Examples:
3266
 
        bzr lookup-revision 33
 
3269
        brz lookup-revision 33
3267
3270
    """
3268
3271
    hidden = True
3269
3272
    takes_args = ['revno']
3313
3316
    takes_options = ['directory',
3314
3317
        Option('format',
3315
3318
               help="Type of file to export to.",
3316
 
               type=unicode),
 
3319
               type=text_type),
3317
3320
        'revision',
3318
3321
        Option('filters', help='Apply content filters to export the '
3319
3322
                'convenient form.'),
3330
3333
    def run(self, dest, branch_or_subdir=None, revision=None, format=None,
3331
3334
        root=None, filters=False, per_file_timestamps=False, uncommitted=False,
3332
3335
        directory=u'.'):
3333
 
        from bzrlib.export import export
 
3336
        from .export import export
3334
3337
 
3335
3338
        if branch_or_subdir is None:
3336
3339
            branch_or_subdir = directory
3350
3353
        try:
3351
3354
            export(export_tree, dest, format, root, subdir, filtered=filters,
3352
3355
                   per_file_timestamps=per_file_timestamps)
3353
 
        except errors.NoSuchExportFormat, e:
 
3356
        except errors.NoSuchExportFormat as e:
3354
3357
            raise errors.BzrCommandError(
3355
3358
                gettext('Unsupported export format: %s') % e.format)
3356
3359
 
3378
3381
    def run(self, filename, revision=None, name_from_revision=False,
3379
3382
            filters=False, directory=None):
3380
3383
        if revision is not None and len(revision) != 1:
3381
 
            raise errors.BzrCommandError(gettext("bzr cat --revision takes exactly"
 
3384
            raise errors.BzrCommandError(gettext("brz cat --revision takes exactly"
3382
3385
                                         " one revision specifier"))
3383
3386
        tree, branch, relpath = \
3384
3387
            _open_directory_or_containing_tree_or_branch(filename, directory)
3418
3421
                    "{0!r} is not present in revision {1}").format(
3419
3422
                        filename, rev_tree.get_revision_id()))
3420
3423
        if filtered:
3421
 
            from bzrlib.filter_tree import ContentFilterTree
 
3424
            from .filter_tree import ContentFilterTree
3422
3425
            filter_tree = ContentFilterTree(rev_tree,
3423
3426
                rev_tree._content_filter_stack)
3424
3427
            content = filter_tree.get_file_text(actual_file_id)
3461
3464
      For example, to commit only changes within foo, but not changes
3462
3465
      within foo/bar::
3463
3466
  
3464
 
        bzr commit foo -x foo/bar
 
3467
        brz commit foo -x foo/bar
3465
3468
  
3466
3469
      A selective commit after a merge is not yet supported.
3467
3470
 
3479
3482
      A common mistake is to forget to add a new file or directory before
3480
3483
      running the commit command. The --strict option checks for unknown
3481
3484
      files and aborts the commit if any are found. More advanced pre-commit
3482
 
      checks can be implemented by defining hooks. See ``bzr help hooks``
 
3485
      checks can be implemented by defining hooks. See ``brz help hooks``
3483
3486
      for details.
3484
3487
 
3485
3488
    :Things to note:
3486
3489
 
3487
3490
      If you accidentially commit the wrong changes or make a spelling
3488
3491
      mistake in the commit message say, you can use the uncommit command
3489
 
      to undo it. See ``bzr help uncommit`` for details.
 
3492
      to undo it. See ``brz help uncommit`` for details.
3490
3493
 
3491
3494
      Hooks can also be configured to run after a commit. This allows you
3492
3495
      to trigger updates to external systems like bug trackers. The --fixes
3493
3496
      option can be used to record the association between a revision and
3494
 
      one or more bugs. See ``bzr help bugs`` for details.
 
3497
      one or more bugs. See ``brz help bugs`` for details.
3495
3498
    """
3496
3499
 
3497
3500
    _see_also = ['add', 'bugs', 'hooks', 'uncommit']
3499
3502
    takes_options = [
3500
3503
            ListOption('exclude', type=str, short_name='x',
3501
3504
                help="Do not consider changes made to a given path."),
3502
 
            Option('message', type=unicode,
 
3505
            Option('message', type=text_type,
3503
3506
                   short_name='m',
3504
3507
                   help="Description of the new revision."),
3505
3508
            'verbose',
3517
3520
                    "format, e.g. '2009-10-10 08:00:00 +0100'."),
3518
3521
             ListOption('fixes', type=str,
3519
3522
                    help="Mark a bug as being fixed by this revision "
3520
 
                         "(see \"bzr help bugs\")."),
3521
 
             ListOption('author', type=unicode,
 
3523
                         "(see \"brz help bugs\")."),
 
3524
             ListOption('author', type=text_type,
3522
3525
                    help="Set the author's name, if it's different "
3523
3526
                         "from the committer."),
3524
3527
             Option('local',
3552
3555
                        "No tracker specified for bug %s. Use the form "
3553
3556
                        "'tracker:id' or specify a default bug tracker "
3554
3557
                        "using the `bugtracker` option.\nSee "
3555
 
                        "\"bzr help bugs\" for more information on this "
 
3558
                        "\"brz help bugs\" for more information on this "
3556
3559
                        "feature. Commit refused.") % fixed_bug)
3557
3560
                tag = default_bugtracker
3558
3561
                bug_id = tokens[0]
3559
3562
            elif len(tokens) != 2:
3560
3563
                raise errors.BzrCommandError(gettext(
3561
3564
                    "Invalid bug %s. Must be in the form of 'tracker:id'. "
3562
 
                    "See \"bzr help bugs\" for more information on this "
 
3565
                    "See \"brz help bugs\" for more information on this "
3563
3566
                    "feature.\nCommit refused.") % fixed_bug)
3564
3567
            else:
3565
3568
                tag, bug_id = tokens
3568
3571
            except errors.UnknownBugTrackerAbbreviation:
3569
3572
                raise errors.BzrCommandError(gettext(
3570
3573
                    'Unrecognized bug %s. Commit refused.') % fixed_bug)
3571
 
            except errors.MalformedBugIdentifier, e:
 
3574
            except errors.MalformedBugIdentifier as e:
3572
3575
                raise errors.BzrCommandError(gettext(
3573
3576
                    "%s\nCommit refused.") % (str(e),))
3574
3577
 
3576
3579
            unchanged=False, strict=False, local=False, fixes=None,
3577
3580
            author=None, show_diff=False, exclude=None, commit_time=None,
3578
3581
            lossy=False):
3579
 
        from bzrlib.errors import (
 
3582
        from .errors import (
3580
3583
            PointlessCommit,
3581
3584
            ConflictsInTree,
3582
3585
            StrictCommitFailed
3583
3586
        )
3584
 
        from bzrlib.msgeditor import (
 
3587
        from .msgeditor import (
3585
3588
            edit_commit_message_encoded,
3586
3589
            generate_commit_message_template,
3587
3590
            make_commit_message_template_encoded,
3592
3595
        if commit_time is not None:
3593
3596
            try:
3594
3597
                commit_stamp, offset = timestamp.parse_patch_date(commit_time)
3595
 
            except ValueError, e:
 
3598
            except ValueError as e:
3596
3599
                raise errors.BzrCommandError(gettext(
3597
3600
                    "Could not parse --commit-time: " + str(e)))
3598
3601
 
3687
3690
                        lossy=lossy)
3688
3691
        except PointlessCommit:
3689
3692
            raise errors.BzrCommandError(gettext("No changes to commit."
3690
 
                " Please 'bzr add' the files you want to commit, or use"
 
3693
                " Please 'brz add' the files you want to commit, or use"
3691
3694
                " --unchanged to force an empty commit."))
3692
3695
        except ConflictsInTree:
3693
3696
            raise errors.BzrCommandError(gettext('Conflicts detected in working '
3694
 
                'tree.  Use "bzr conflicts" to list, "bzr resolve FILE" to'
 
3697
                'tree.  Use "brz conflicts" to list, "brz resolve FILE" to'
3695
3698
                ' resolve.'))
3696
3699
        except StrictCommitFailed:
3697
3700
            raise errors.BzrCommandError(gettext("Commit refused because there are"
3698
3701
                              " unknown files in the working tree."))
3699
 
        except errors.BoundBranchOutOfDate, e:
 
3702
        except errors.BoundBranchOutOfDate as e:
3700
3703
            e.extra_help = (gettext("\n"
3701
3704
                'To commit to master branch, run update and then commit.\n'
3702
3705
                'You can also pass --local to commit to continue working '
3708
3711
    __doc__ = """Validate working tree structure, branch consistency and repository history.
3709
3712
 
3710
3713
    This command checks various invariants about branch and repository storage
3711
 
    to detect data corruption or bzr bugs.
 
3714
    to detect data corruption or brz bugs.
3712
3715
 
3713
3716
    The working tree and branch checks will only give output if a problem is
3714
3717
    detected. The output fields of the repository check are:
3743
3746
 
3744
3747
        Check the tree and branch at 'foo'::
3745
3748
 
3746
 
            bzr check --tree --branch foo
 
3749
            brz check --tree --branch foo
3747
3750
 
3748
3751
        Check only the repository at 'bar'::
3749
3752
 
3750
 
            bzr check --repo bar
 
3753
            brz check --repo bar
3751
3754
 
3752
3755
        Check everything at 'baz'::
3753
3756
 
3754
 
            bzr check baz
 
3757
            brz check baz
3755
3758
    """
3756
3759
 
3757
3760
    _see_also = ['reconcile']
3766
3769
 
3767
3770
    def run(self, path=None, verbose=False, branch=False, repo=False,
3768
3771
            tree=False):
3769
 
        from bzrlib.check import check_dwim
 
3772
        from .check import check_dwim
3770
3773
        if path is None:
3771
3774
            path = '.'
3772
3775
        if not branch and not repo and not tree:
3811
3814
    takes_args = ['url?']
3812
3815
    takes_options = [
3813
3816
        RegistryOption('format',
3814
 
            help='Upgrade to a specific format.  See "bzr help'
 
3817
            help='Upgrade to a specific format.  See "brz help'
3815
3818
                 ' formats" for details.',
3816
 
            lazy_registry=('bzrlib.controldir', 'format_registry'),
 
3819
            lazy_registry=('breezy.controldir', 'format_registry'),
3817
3820
            converter=lambda name: controldir.format_registry.make_bzrdir(name),
3818
3821
            value_switches=True, title='Branch format'),
3819
3822
        Option('clean',
3823
3826
    ]
3824
3827
 
3825
3828
    def run(self, url='.', format=None, clean=False, dry_run=False):
3826
 
        from bzrlib.upgrade import upgrade
 
3829
        from .upgrade import upgrade
3827
3830
        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)
3828
3831
        if exceptions:
3829
3832
            if len(exceptions) == 1:
3834
3837
 
3835
3838
 
3836
3839
class cmd_whoami(Command):
3837
 
    __doc__ = """Show or set bzr user id.
 
3840
    __doc__ = """Show or set brz user id.
3838
3841
 
3839
3842
    :Examples:
3840
3843
        Show the email of the current user::
3841
3844
 
3842
 
            bzr whoami --email
 
3845
            brz whoami --email
3843
3846
 
3844
3847
        Set the current user::
3845
3848
 
3846
 
            bzr whoami "Frank Chu <fchu@example.com>"
 
3849
            brz whoami "Frank Chu <fchu@example.com>"
3847
3850
    """
3848
3851
    takes_options = [ 'directory',
3849
3852
                      Option('email',
3881
3884
        # display a warning if an email address isn't included in the given name.
3882
3885
        try:
3883
3886
            _mod_config.extract_email_address(name)
3884
 
        except errors.NoEmailInUsername, e:
 
3887
        except errors.NoEmailInUsername as e:
3885
3888
            warning('"%s" does not seem to contain an email address.  '
3886
3889
                    'This is allowed, but not recommended.', name)
3887
3890
 
3930
3933
    :Examples:
3931
3934
        Show the current aliases::
3932
3935
 
3933
 
            bzr alias
 
3936
            brz alias
3934
3937
 
3935
3938
        Show the alias specified for 'll'::
3936
3939
 
3937
 
            bzr alias ll
 
3940
            brz alias ll
3938
3941
 
3939
3942
        Set an alias for 'll'::
3940
3943
 
3941
 
            bzr alias ll="log --line -r-10..-1"
 
3944
            brz alias ll="log --line -r-10..-1"
3942
3945
 
3943
3946
        To remove an alias for 'll'::
3944
3947
 
3945
 
            bzr alias --remove ll
 
3948
            brz alias --remove ll
3946
3949
 
3947
3950
    """
3948
3951
    takes_args = ['name?']
3965
3968
    def remove_alias(self, alias_name):
3966
3969
        if alias_name is None:
3967
3970
            raise errors.BzrCommandError(gettext(
3968
 
                'bzr alias --remove expects an alias to remove.'))
 
3971
                'brz alias --remove expects an alias to remove.'))
3969
3972
        # If alias is not found, print something like:
3970
3973
        # unalias: foo: not found
3971
3974
        c = _mod_config.GlobalConfig()
3976
3979
        """Print out the defined aliases in a similar format to bash."""
3977
3980
        aliases = _mod_config.GlobalConfig().get_aliases()
3978
3981
        for key, value in sorted(aliases.iteritems()):
3979
 
            self.outf.write('bzr alias %s="%s"\n' % (key, value))
 
3982
            self.outf.write('brz alias %s="%s"\n' % (key, value))
3980
3983
 
3981
3984
    @display_command
3982
3985
    def print_alias(self, alias_name):
3983
 
        from bzrlib.commands import get_alias
 
3986
        from .commands import get_alias
3984
3987
        alias = get_alias(alias_name)
3985
3988
        if alias is None:
3986
 
            self.outf.write("bzr alias: %s: not found\n" % alias_name)
 
3989
            self.outf.write("brz alias: %s: not found\n" % alias_name)
3987
3990
        else:
3988
3991
            self.outf.write(
3989
 
                'bzr alias %s="%s"\n' % (alias_name, ' '.join(alias)))
 
3992
                'brz alias %s="%s"\n' % (alias_name, ' '.join(alias)))
3990
3993
 
3991
3994
    def set_alias(self, alias_name, alias_command):
3992
3995
        """Save the alias in the global config."""
4028
4031
    Tests that need working space on disk use a common temporary directory,
4029
4032
    typically inside $TMPDIR or /tmp.
4030
4033
 
4031
 
    If you set BZR_TEST_PDB=1 when running selftest, failing tests will drop
 
4034
    If you set BRZ_TEST_PDB=1 when running selftest, failing tests will drop
4032
4035
    into a pdb postmortem session.
4033
4036
 
4034
4037
    The --coverage=DIRNAME global option produces a report with covered code
4037
4040
    :Examples:
4038
4041
        Run only tests relating to 'ignore'::
4039
4042
 
4040
 
            bzr selftest ignore
 
4043
            brz selftest ignore
4041
4044
 
4042
4045
        Disable plugins and list tests as they're run::
4043
4046
 
4044
 
            bzr --no-plugins selftest -v
 
4047
            brz --no-plugins selftest -v
4045
4048
    """
4046
4049
    # NB: this is used from the class without creating an instance, which is
4047
4050
    # why it does not have a self parameter.
4048
4051
    def get_transport_type(typestring):
4049
4052
        """Parse and return a transport specifier."""
4050
4053
        if typestring == "sftp":
4051
 
            from bzrlib.tests import stub_sftp
 
4054
            from .tests import stub_sftp
4052
4055
            return stub_sftp.SFTPAbsoluteServer
4053
4056
        elif typestring == "memory":
4054
 
            from bzrlib.tests import test_server
 
4057
            from .tests import test_server
4055
4058
            return memory.MemoryServer
4056
4059
        elif typestring == "fakenfs":
4057
 
            from bzrlib.tests import test_server
 
4060
            from .tests import test_server
4058
4061
            return test_server.FakeNFSServer
4059
4062
        msg = "No known transport type %s. Supported types are: sftp\n" %\
4060
4063
            (typestring)
4087
4090
                            help='List the tests instead of running them.'),
4088
4091
                     RegistryOption('parallel',
4089
4092
                        help="Run the test suite in parallel.",
4090
 
                        lazy_registry=('bzrlib.tests', 'parallel_registry'),
 
4093
                        lazy_registry=('breezy.tests', 'parallel_registry'),
4091
4094
                        value_switches=False,
4092
4095
                        ),
4093
4096
                     Option('randomize', type=str, argname="SEED",
4136
4139
        # backtraces.
4137
4140
        lazy_import.disallow_proxying()
4138
4141
 
4139
 
        from bzrlib import tests
 
4142
        from . import tests
4140
4143
 
4141
4144
        if testspecs_list is not None:
4142
4145
            pattern = '|'.join(testspecs_list)
4144
4147
            pattern = ".*"
4145
4148
        if subunit:
4146
4149
            try:
4147
 
                from bzrlib.tests import SubUnitBzrRunner
 
4150
                from .tests import SubUnitBzrRunner
4148
4151
            except ImportError:
4149
4152
                raise errors.BzrCommandError(gettext("subunit not available. subunit "
4150
4153
                    "needs to be installed to use --subunit."))
4163
4166
                'suite_decorators', []).append(parallel)
4164
4167
        if benchmark:
4165
4168
            raise errors.BzrCommandError(gettext(
4166
 
                "--benchmark is no longer supported from bzr 2.2; "
 
4169
                "--benchmark is no longer supported from brz 2.2; "
4167
4170
                "use bzr-usertest instead"))
4168
4171
        test_suite_factory = None
4169
4172
        if not exclude:
4210
4213
 
4211
4214
 
4212
4215
class cmd_version(Command):
4213
 
    __doc__ = """Show version of bzr."""
 
4216
    __doc__ = """Show version of brz."""
4214
4217
 
4215
4218
    encoding_type = 'replace'
4216
4219
    takes_options = [
4219
4222
 
4220
4223
    @display_command
4221
4224
    def run(self, short=False):
4222
 
        from bzrlib.version import show_version
 
4225
        from .version import show_version
4223
4226
        if short:
4224
 
            self.outf.write(bzrlib.version_string + '\n')
 
4227
            self.outf.write(breezy.version_string + '\n')
4225
4228
        else:
4226
4229
            show_version(to_file=self.outf)
4227
4230
 
4245
4248
 
4246
4249
    @display_command
4247
4250
    def run(self, branch, other):
4248
 
        from bzrlib.revision import ensure_null
 
4251
        from .revision import ensure_null
4249
4252
 
4250
4253
        branch1 = Branch.open_containing(branch)[0]
4251
4254
        branch2 = Branch.open_containing(other)[0]
4265
4268
 
4266
4269
    The source of the merge can be specified either in the form of a branch,
4267
4270
    or in the form of a path to a file containing a merge directive generated
4268
 
    with bzr send. If neither is specified, the default is the upstream branch
 
4271
    with brz send. If neither is specified, the default is the upstream branch
4269
4272
    or the branch most recently merged using --remember.  The source of the
4270
4273
    merge may also be specified in the form of a path to a file in another
4271
4274
    branch:  in this case, only the modifications to that file are merged into
4272
4275
    the current working tree.
4273
4276
 
4274
 
    When merging from a branch, by default bzr will try to merge in all new
 
4277
    When merging from a branch, by default brz will try to merge in all new
4275
4278
    work from the other branch, automatically determining an appropriate base
4276
4279
    revision.  If this fails, you may need to give an explicit base.
4277
4280
 
4278
 
    To pick a different ending revision, pass "--revision OTHER".  bzr will
 
4281
    To pick a different ending revision, pass "--revision OTHER".  brz will
4279
4282
    try to merge in all new work up to and including revision OTHER.
4280
4283
 
4281
4284
    If you specify two values, "--revision BASE..OTHER", only revisions BASE
4293
4296
    it will mark a conflict.  A conflict means that you need to fix something,
4294
4297
    before you can commit.
4295
4298
 
4296
 
    Use bzr resolve when you have fixed a problem.  See also bzr conflicts.
 
4299
    Use brz resolve when you have fixed a problem.  See also brz conflicts.
4297
4300
 
4298
4301
    If there is no default branch set, the first merge will set it (use
4299
4302
    --no-remember to avoid setting it). After that, you can omit the branch
4301
4304
    only be saved if the remote location can be accessed.
4302
4305
 
4303
4306
    The results of the merge are placed into the destination working
4304
 
    directory, where they can be reviewed (with bzr diff), tested, and then
 
4307
    directory, where they can be reviewed (with brz diff), tested, and then
4305
4308
    committed to record the result of the merge.
4306
4309
 
4307
4310
    merge refuses to run if there are any uncommitted changes, unless
4318
4321
    you to apply each diff hunk and file change, similar to "shelve".
4319
4322
 
4320
4323
    :Examples:
4321
 
        To merge all new revisions from bzr.dev::
4322
 
 
4323
 
            bzr merge ../bzr.dev
4324
 
 
4325
 
        To merge changes up to and including revision 82 from bzr.dev::
4326
 
 
4327
 
            bzr merge -r 82 ../bzr.dev
 
4324
        To merge all new revisions from brz.dev::
 
4325
 
 
4326
            brz merge ../brz.dev
 
4327
 
 
4328
        To merge changes up to and including revision 82 from brz.dev::
 
4329
 
 
4330
            brz merge -r 82 ../brz.dev
4328
4331
 
4329
4332
        To merge the changes introduced by 82, without previous changes::
4330
4333
 
4331
 
            bzr merge -r 81..82 ../bzr.dev
 
4334
            brz merge -r 81..82 ../brz.dev
4332
4335
 
4333
4336
        To apply a merge directive contained in /tmp/merge::
4334
4337
 
4335
 
            bzr merge /tmp/merge
 
4338
            brz merge /tmp/merge
4336
4339
 
4337
4340
        To create a merge revision with three parents from two branches
4338
4341
        feature1a and feature1b:
4339
4342
 
4340
 
            bzr merge ../feature1a
4341
 
            bzr merge ../feature1b --force
4342
 
            bzr commit -m 'revision with three parents'
 
4343
            brz merge ../feature1a
 
4344
            brz merge ../feature1b --force
 
4345
            brz commit -m 'revision with three parents'
4343
4346
    """
4344
4347
 
4345
4348
    encoding_type = 'exact'
4461
4464
        if merger.this_basis is None:
4462
4465
            raise errors.BzrCommandError(gettext(
4463
4466
                "This branch has no commits."
4464
 
                " (perhaps you would prefer 'bzr pull')"))
 
4467
                " (perhaps you would prefer 'brz pull')"))
4465
4468
        if preview:
4466
4469
            return self._do_preview(merger)
4467
4470
        elif interactive:
4478
4481
        return result_tree
4479
4482
 
4480
4483
    def _do_preview(self, merger):
4481
 
        from bzrlib.diff import show_diff_trees
 
4484
        from .diff import show_diff_trees
4482
4485
        result_tree = self._get_preview(merger)
4483
4486
        path_encoding = osutils.get_diff_header_encoding()
4484
4487
        show_diff_trees(merger.this_tree, result_tree, self.outf,
4504
4507
        Shelver to selectively remove the differences between the working tree
4505
4508
        and the preview tree.
4506
4509
        """
4507
 
        from bzrlib import shelf_ui
 
4510
        from . import shelf_ui
4508
4511
        result_tree = self._get_preview(merger)
4509
 
        writer = bzrlib.option.diff_writer_registry.get()
 
4512
        writer = breezy.option.diff_writer_registry.get()
4510
4513
        shelver = shelf_ui.Shelver(merger.this_tree, result_tree, destroy=True,
4511
4514
                                   reporter=shelf_ui.ApplyReporter(),
4512
4515
                                   diff_writer=writer(sys.stdout))
4537
4540
    def _get_merger_from_branch(self, tree, location, revision, remember,
4538
4541
                                possible_transports, pb):
4539
4542
        """Produce a merger from a location, assuming it refers to a branch."""
4540
 
        from bzrlib.tag import _merge_tags_if_possible
 
4543
        from .tag import _merge_tags_if_possible
4541
4544
        # find the branch locations
4542
4545
        other_loc, user_location = self._select_branch_location(tree, location,
4543
4546
            revision, -1)
4664
4667
        Re-do the merge of all conflicted files, and show the base text in
4665
4668
        conflict regions, in addition to the usual THIS and OTHER texts::
4666
4669
 
4667
 
            bzr remerge --show-base
 
4670
            brz remerge --show-base
4668
4671
 
4669
4672
        Re-do the merge of "foobar", using the weave merge algorithm, with
4670
4673
        additional processing to reduce the size of conflict regions::
4671
4674
 
4672
 
            bzr remerge --merge-type weave --reprocess foobar
 
4675
            brz remerge --merge-type weave --reprocess foobar
4673
4676
    """
4674
4677
    takes_args = ['file*']
4675
4678
    takes_options = [
4681
4684
 
4682
4685
    def run(self, file_list=None, merge_type=None, show_base=False,
4683
4686
            reprocess=False):
4684
 
        from bzrlib.conflicts import restore
 
4687
        from .conflicts import restore
4685
4688
        if merge_type is None:
4686
4689
            merge_type = _mod_merge.Merge3Merger
4687
4690
        tree, file_list = WorkingTree.open_containing_paths(file_list)
4782
4785
    not yet committed. These revisions will be included as additional parents
4783
4786
    of the next commit.  Normally, using revert clears that list as well as
4784
4787
    reverting the files.  If any files are specified, revert leaves the list
4785
 
    of uncommitted merges alone and reverts only the files.  Use ``bzr revert
 
4788
    of uncommitted merges alone and reverts only the files.  Use ``brz revert
4786
4789
    .`` in the tree root to revert all files but keep the recorded merges,
4787
 
    and ``bzr revert --forget-merges`` to clear the pending merge list without
 
4790
    and ``brz revert --forget-merges`` to clear the pending merge list without
4788
4791
    reverting any files.
4789
4792
 
4790
 
    Using "bzr revert --forget-merges", it is possible to apply all of the
 
4793
    Using "brz revert --forget-merges", it is possible to apply all of the
4791
4794
    changes from a branch in a single revision.  To do this, perform the merge
4792
4795
    as desired.  Then doing revert with the "--forget-merges" option will keep
4793
4796
    the content of the tree as it was, but it will clear the list of pending
4846
4849
 
4847
4850
    @display_command
4848
4851
    def run(self, topic=None, long=False):
4849
 
        import bzrlib.help
 
4852
        import breezy.help
4850
4853
        if topic is None and long:
4851
4854
            topic = "commands"
4852
 
        bzrlib.help.help(topic)
 
4855
        breezy.help.help(topic)
4853
4856
 
4854
4857
 
4855
4858
class cmd_shell_complete(Command):
4856
4859
    __doc__ = """Show appropriate completions for context.
4857
4860
 
4858
 
    For a list of all available commands, say 'bzr shell-complete'.
 
4861
    For a list of all available commands, say 'brz shell-complete'.
4859
4862
    """
4860
4863
    takes_args = ['context?']
4861
4864
    aliases = ['s-c']
4863
4866
 
4864
4867
    @display_command
4865
4868
    def run(self, context=None):
4866
 
        from bzrlib import shellcomplete
 
4869
        from . import shellcomplete
4867
4870
        shellcomplete.shellcomplete(context)
4868
4871
 
4869
4872
 
4885
4888
        Determine the missing revisions between this and the branch at the
4886
4889
        remembered pull location::
4887
4890
 
4888
 
            bzr missing
 
4891
            brz missing
4889
4892
 
4890
4893
        Determine the missing revisions between this and another branch::
4891
4894
 
4892
 
            bzr missing http://server/branch
 
4895
            brz missing http://server/branch
4893
4896
 
4894
4897
        Determine the missing revisions up to a specific revision on the other
4895
4898
        branch::
4896
4899
 
4897
 
            bzr missing -r ..-10
 
4900
            brz missing -r ..-10
4898
4901
 
4899
4902
        Determine the missing revisions up to a specific revision on this
4900
4903
        branch::
4901
4904
 
4902
 
            bzr missing --my-revision ..-10
 
4905
            brz missing --my-revision ..-10
4903
4906
    """
4904
4907
 
4905
4908
    _see_also = ['merge', 'pull']
4938
4941
            include_merged=None, revision=None, my_revision=None,
4939
4942
            directory=u'.',
4940
4943
            include_merges=symbol_versioning.DEPRECATED_PARAMETER):
4941
 
        from bzrlib.missing import find_unmerged, iter_log_revisions
 
4944
        from breezy.missing import find_unmerged, iter_log_revisions
4942
4945
        def message(s):
4943
4946
            if not is_quiet():
4944
4947
                self.outf.write(s)
5126
5129
 
5127
5130
    @display_command
5128
5131
    def run(self, verbose=False):
5129
 
        from bzrlib import plugin
 
5132
        from . import plugin
5130
5133
        # Don't give writelines a generator as some codecs don't like that
5131
5134
        self.outf.writelines(
5132
5135
            list(plugin.describe_plugins(show_paths=verbose)))
5143
5146
    encoding_type = 'exact'
5144
5147
    @display_command
5145
5148
    def run(self, branch=u'.', revision=None, long=False, strict=False):
5146
 
        from bzrlib.testament import Testament, StrictTestament
 
5149
        from .testament import Testament, StrictTestament
5147
5150
        if strict is True:
5148
5151
            testament_class = StrictTestament
5149
5152
        else:
5189
5192
    @display_command
5190
5193
    def run(self, filename, all=False, long=False, revision=None,
5191
5194
            show_ids=False, directory=None):
5192
 
        from bzrlib.annotate import (
 
5195
        from .annotate import (
5193
5196
            annotate_file_tree,
5194
5197
            )
5195
5198
        wt, branch, relpath = \
5234
5237
        return self._run(b, revision_id_list, revision)
5235
5238
 
5236
5239
    def _run(self, b, revision_id_list, revision):
5237
 
        import bzrlib.gpg as gpg
 
5240
        from . import gpg
5238
5241
        gpg_strategy = gpg.GPGStrategy(b.get_config_stack())
5239
5242
        if revision_id_list is not None:
5240
5243
            b.repository.start_write_group()
5349
5352
    remove anything.
5350
5353
 
5351
5354
    If --revision is specified, uncommit revisions to leave the branch at the
5352
 
    specified revision.  For example, "bzr uncommit -r 15" will leave the
 
5355
    specified revision.  For example, "brz uncommit -r 15" will leave the
5353
5356
    branch at revision 15.
5354
5357
 
5355
5358
    Uncommit leaves the working tree ready for a new commit.  The only change
5397
5400
 
5398
5401
    def _run(self, b, tree, dry_run, verbose, revision, force, local,
5399
5402
             keep_tags):
5400
 
        from bzrlib.log import log_formatter, show_log
5401
 
        from bzrlib.uncommit import uncommit
 
5403
        from .log import log_formatter, show_log
 
5404
        from .uncommit import uncommit
5402
5405
 
5403
5406
        last_revno, last_rev_id = b.last_revision_info()
5404
5407
 
5407
5410
            revno = last_revno
5408
5411
            rev_id = last_rev_id
5409
5412
        else:
5410
 
            # 'bzr uncommit -r 10' actually means uncommit
 
5413
            # 'brz uncommit -r 10' actually means uncommit
5411
5414
            # so that the final tree is at revno 10.
5412
 
            # but bzrlib.uncommit.uncommit() actually uncommits
 
5415
            # but breezy.uncommit.uncommit() actually uncommits
5413
5416
            # the revisions that are supplied.
5414
5417
            # So we need to offset it by one
5415
5418
            revno = revision[0].in_history(b).revno + 1
5440
5443
        if not force:
5441
5444
            if not ui.ui_factory.confirm_action(
5442
5445
                    gettext(u'Uncommit these revisions'),
5443
 
                    'bzrlib.builtins.uncommit',
 
5446
                    'breezy.builtins.uncommit',
5444
5447
                    {}):
5445
5448
                self.outf.write(gettext('Canceled\n'))
5446
5449
                return 0
5450
5453
        uncommit(b, tree=tree, dry_run=dry_run, verbose=verbose,
5451
5454
                 revno=revno, local=local, keep_tags=keep_tags)
5452
5455
        self.outf.write(gettext('You can restore the old tip by running:\n'
5453
 
             '  bzr pull . -r revid:%s\n') % last_rev_id)
 
5456
             '  brz pull . -r revid:%s\n') % last_rev_id)
5454
5457
 
5455
5458
 
5456
5459
class cmd_break_lock(Command):
5462
5465
    CAUTION: Locks should only be broken when you are sure that the process
5463
5466
    holding the lock has been stopped.
5464
5467
 
5465
 
    You can get information on what locks are open via the 'bzr info
 
5468
    You can get information on what locks are open via the 'brz info
5466
5469
    [location]' command.
5467
5470
 
5468
5471
    :Examples:
5469
 
        bzr break-lock
5470
 
        bzr break-lock bzr+ssh://example.com/bzr/foo
5471
 
        bzr break-lock --conf ~/.bazaar
 
5472
        brz break-lock
 
5473
        brz break-lock brz+ssh://example.com/brz/foo
 
5474
        brz break-lock --conf ~/.bazaar
5472
5475
    """
5473
5476
 
5474
5477
    takes_args = ['location?']
5485
5488
        if force:
5486
5489
            ui.ui_factory = ui.ConfirmationUserInterfacePolicy(ui.ui_factory,
5487
5490
                None,
5488
 
                {'bzrlib.lockdir.break': True})
 
5491
                {'breezy.lockdir.break': True})
5489
5492
        if config:
5490
5493
            conf = _mod_config.LockableConfig(file_name=location)
5491
5494
            conf.break_lock()
5498
5501
 
5499
5502
 
5500
5503
class cmd_wait_until_signalled(Command):
5501
 
    __doc__ = """Test helper for test_start_and_stop_bzr_subprocess_send_signal.
 
5504
    __doc__ = """Test helper for test_start_and_stop_brz_subprocess_send_signal.
5502
5505
 
5503
5506
    This just prints a line to signal when it is ready, then blocks on stdin.
5504
5507
    """
5512
5515
 
5513
5516
 
5514
5517
class cmd_serve(Command):
5515
 
    __doc__ = """Run the bzr server."""
 
5518
    __doc__ = """Run the brz server."""
5516
5519
 
5517
5520
    aliases = ['server']
5518
5521
 
5521
5524
               help='Serve on stdin/out for use from inetd or sshd.'),
5522
5525
        RegistryOption('protocol',
5523
5526
               help="Protocol to serve.",
5524
 
               lazy_registry=('bzrlib.transport', 'transport_server_registry'),
 
5527
               lazy_registry=('breezy.transport', 'transport_server_registry'),
5525
5528
               value_switches=True),
5526
5529
        Option('listen',
5527
5530
               help='Listen for connections on nominated address.', type=str),
5535
5538
        Option('allow-writes',
5536
5539
               help='By default the server is a readonly server.  Supplying '
5537
5540
                    '--allow-writes enables write access to the contents of '
5538
 
                    'the served directory and below.  Note that ``bzr serve`` '
 
5541
                    'the served directory and below.  Note that ``brz serve`` '
5539
5542
                    'does not perform authentication, so unless some form of '
5540
5543
                    'external authentication is arranged supplying this '
5541
5544
                    'option leads to global uncontrolled write access to your '
5547
5550
 
5548
5551
    def run(self, listen=None, port=None, inet=False, directory=None,
5549
5552
            allow_writes=False, protocol=None, client_timeout=None):
5550
 
        from bzrlib import transport
 
5553
        from . import transport
5551
5554
        if directory is None:
5552
 
            directory = os.getcwd()
 
5555
            directory = osutils.getcwd()
5553
5556
        if protocol is None:
5554
5557
            protocol = transport.transport_server_registry.get()
5555
5558
        url = transport.location_to_url(directory)
5565
5568
    This command requires the target tree to be in a rich-root format.
5566
5569
 
5567
5570
    The TREE argument should be an independent tree, inside another tree, but
5568
 
    not part of it.  (Such trees can be produced by "bzr split", but also by
5569
 
    running "bzr branch" with the target inside a tree.)
 
5571
    not part of it.  (Such trees can be produced by "brz split", but also by
 
5572
    running "brz branch" with the target inside a tree.)
5570
5573
 
5571
5574
    The result is a combined tree, with the subtree no longer an independent
5572
5575
    part.  This is marked as a merge of the subtree into the containing tree,
5587
5590
        if not repo.supports_rich_root():
5588
5591
            raise errors.BzrCommandError(gettext(
5589
5592
                "Can't join trees because %s doesn't support rich root data.\n"
5590
 
                "You can use bzr upgrade on the repository.")
 
5593
                "You can use brz upgrade on the repository.")
5591
5594
                % (repo,))
5592
5595
        if reference:
5593
5596
            try:
5594
5597
                containing_tree.add_reference(sub_tree)
5595
 
            except errors.BadReferenceTarget, e:
 
5598
            except errors.BadReferenceTarget as e:
5596
5599
                # XXX: Would be better to just raise a nicely printable
5597
5600
                # exception from the real origin.  Also below.  mbp 20070306
5598
5601
                raise errors.BzrCommandError(
5600
5603
        else:
5601
5604
            try:
5602
5605
                containing_tree.subsume(sub_tree)
5603
 
            except errors.BadSubsumeSource, e:
 
5606
            except errors.BadSubsumeSource as e:
5604
5607
                raise errors.BzrCommandError(
5605
5608
                       gettext("Cannot join {0}.  {1}").format(tree, e.reason))
5606
5609
 
5676
5679
    def run(self, submit_branch=None, public_branch=None, patch_type='bundle',
5677
5680
            sign=False, revision=None, mail_to=None, message=None,
5678
5681
            directory=u'.'):
5679
 
        from bzrlib.revision import ensure_null, NULL_REVISION
 
5682
        from .revision import ensure_null, NULL_REVISION
5680
5683
        include_patch, include_bundle = {
5681
5684
            'plain': (False, False),
5682
5685
            'diff': (True, False),
5706
5709
        base_revision_id = None
5707
5710
        if revision is not None:
5708
5711
            if len(revision) > 2:
5709
 
                raise errors.BzrCommandError(gettext('bzr merge-directive takes '
 
5712
                raise errors.BzrCommandError(gettext('brz merge-directive takes '
5710
5713
                    'at most two one revision identifiers'))
5711
5714
            revision_id = revision[-1].as_revision_id(branch)
5712
5715
            if len(revision) == 2:
5746
5749
      directly from the merge directive, without retrieving data from a
5747
5750
      branch.
5748
5751
 
5749
 
    `bzr send` creates a compact data set that, when applied using bzr
 
5752
    `brz send` creates a compact data set that, when applied using brz
5750
5753
    merge, has the same effect as merging from the source branch.  
5751
5754
    
5752
5755
    By default the merge directive is self-contained and can be applied to any
5771
5774
    omit the location to use the default.  To change the default, use
5772
5775
    --remember. The value will only be saved if the location can be accessed.
5773
5776
 
5774
 
    In order to calculate those changes, bzr must analyse the submit branch.
 
5777
    In order to calculate those changes, brz must analyse the submit branch.
5775
5778
    Therefore it is most efficient for the submit branch to be a local mirror.
5776
5779
    If a public location is known for the submit_branch, that location is used
5777
5780
    in the merge directive.
5801
5804
    default.  "0.9" uses revision bundle format 0.9 and merge directive
5802
5805
    format 1.  It is compatible with Bazaar 0.12 - 0.18.
5803
5806
 
5804
 
    The merge directives created by bzr send may be applied using bzr merge or
5805
 
    bzr pull by specifying a file containing a merge directive as the location.
 
5807
    The merge directives created by brz send may be applied using brz merge or
 
5808
    brz pull by specifying a file containing a merge directive as the location.
5806
5809
 
5807
 
    bzr send makes extensive use of public locations to map local locations into
5808
 
    URLs that can be used by other people.  See `bzr help configuration` to
5809
 
    set them, and use `bzr info` to display them.
 
5810
    brz send makes extensive use of public locations to map local locations into
 
5811
    URLs that can be used by other people.  See `brz help configuration` to
 
5812
    set them, and use `brz info` to display them.
5810
5813
    """
5811
5814
 
5812
5815
    encoding_type = 'exact'
5826
5829
               help='Branch to generate the submission from, '
5827
5830
               'rather than the one containing the working directory.',
5828
5831
               short_name='f',
5829
 
               type=unicode),
 
5832
               type=text_type),
5830
5833
        Option('output', short_name='o',
5831
5834
               help='Write merge directive to this file or directory; '
5832
5835
                    'use - for stdout.',
5833
 
               type=unicode),
 
5836
               type=text_type),
5834
5837
        Option('strict',
5835
5838
               help='Refuse to send if there are uncommitted changes in'
5836
5839
               ' the working tree, --no-strict disables the check.'),
5837
5840
        Option('mail-to', help='Mail the request to this address.',
5838
 
               type=unicode),
 
5841
               type=text_type),
5839
5842
        'revision',
5840
5843
        'message',
5841
 
        Option('body', help='Body for the email.', type=unicode),
 
5844
        Option('body', help='Body for the email.', type=text_type),
5842
5845
        RegistryOption('format',
5843
5846
                       help='Use the specified output format.',
5844
 
                       lazy_registry=('bzrlib.send', 'format_registry')),
 
5847
                       lazy_registry=('breezy.send', 'format_registry')),
5845
5848
        ]
5846
5849
 
5847
5850
    def run(self, submit_branch=None, public_branch=None, no_bundle=False,
5848
5851
            no_patch=False, revision=None, remember=None, output=None,
5849
5852
            format=None, mail_to=None, message=None, body=None,
5850
5853
            strict=None, **kwargs):
5851
 
        from bzrlib.send import send
 
5854
        from .send import send
5852
5855
        return send(submit_branch, revision, public_branch, remember,
5853
5856
                    format, no_bundle, no_patch, output,
5854
5857
                    kwargs.get('from', '.'), mail_to, message, body,
5900
5903
               help='Branch to generate the submission from, '
5901
5904
               'rather than the one containing the working directory.',
5902
5905
               short_name='f',
5903
 
               type=unicode),
 
5906
               type=text_type),
5904
5907
        Option('output', short_name='o', help='Write directive to this file.',
5905
 
               type=unicode),
 
5908
               type=text_type),
5906
5909
        Option('strict',
5907
5910
               help='Refuse to bundle revisions if there are uncommitted'
5908
5911
               ' changes in the working tree, --no-strict disables the check.'),
5909
5912
        'revision',
5910
5913
        RegistryOption('format',
5911
5914
                       help='Use the specified output format.',
5912
 
                       lazy_registry=('bzrlib.send', 'format_registry')),
 
5915
                       lazy_registry=('breezy.send', 'format_registry')),
5913
5916
        ]
5914
5917
    aliases = ['bundle']
5915
5918
 
5922
5925
            format=None, strict=None, **kwargs):
5923
5926
        if output is None:
5924
5927
            output = '-'
5925
 
        from bzrlib.send import send
 
5928
        from .send import send
5926
5929
        return send(submit_branch, revision, public_branch, remember,
5927
5930
                         format, no_bundle, no_patch, output,
5928
5931
                         kwargs.get('from', '.'), None, None, None,
5942
5945
    It is an error to give a tag name that already exists unless you pass
5943
5946
    --force, in which case the tag is moved to point to the new revision.
5944
5947
 
5945
 
    To rename a tag (change the name but keep it on the same revsion), run ``bzr
5946
 
    tag new-name -r tag:old-name`` and then ``bzr tag --delete oldname``.
 
5948
    To rename a tag (change the name but keep it on the same revsion), run ``brz
 
5949
    tag new-name -r tag:old-name`` and then ``brz tag --delete oldname``.
5947
5950
 
5948
5951
    If no tag name is specified it will be determined through the 
5949
5952
    'automatic_tag_name' hook. This can e.g. be used to automatically tag
5950
 
    upstream releases by reading configure.ac. See ``bzr help hooks`` for
 
5953
    upstream releases by reading configure.ac. See ``brz help hooks`` for
5951
5954
    details.
5952
5955
    """
5953
5956
 
6020
6023
            help='Branch whose tags should be displayed.'),
6021
6024
        RegistryOption('sort',
6022
6025
            'Sort tags by different criteria.', title='Sorting',
6023
 
            lazy_registry=('bzrlib.tag', 'tag_sort_methods')
 
6026
            lazy_registry=('breezy.tag', 'tag_sort_methods')
6024
6027
            ),
6025
6028
        'show-ids',
6026
6029
        'revision',
6028
6031
 
6029
6032
    @display_command
6030
6033
    def run(self, directory='.', sort=None, show_ids=False, revision=None):
6031
 
        from bzrlib.tag import tag_sort_methods
 
6034
        from .tag import tag_sort_methods
6032
6035
        branch, relpath = Branch.open_containing(directory)
6033
6036
 
6034
6037
        tags = branch.tags.get_tag_dict().items()
6088
6091
 
6089
6092
 
6090
6093
class cmd_reconfigure(Command):
6091
 
    __doc__ = """Reconfigure the type of a bzr directory.
 
6094
    __doc__ = """Reconfigure the type of a brz directory.
6092
6095
 
6093
6096
    A target configuration must be specified.
6094
6097
 
6140
6143
            ' will be lost.'),
6141
6144
        Option('stacked-on',
6142
6145
            help='Reconfigure a branch to be stacked on another branch.',
6143
 
            type=unicode,
 
6146
            type=text_type,
6144
6147
            ),
6145
6148
        Option('unstacked',
6146
6149
            help='Reconfigure a branch to be unstacked.  This '
6239
6242
 
6240
6243
    def run(self, to_location=None, force=False, create_branch=False,
6241
6244
            revision=None, directory=u'.', store=False):
6242
 
        from bzrlib import switch
 
6245
        from . import switch
6243
6246
        tree_location = directory
6244
6247
        revision = _get_one_revision('switch', revision)
6245
6248
        possible_transports = []
6308
6311
    :Examples:
6309
6312
      To define the current view::
6310
6313
 
6311
 
        bzr view file1 dir1 ...
 
6314
        brz view file1 dir1 ...
6312
6315
 
6313
6316
      To list the current view::
6314
6317
 
6315
 
        bzr view
 
6318
        brz view
6316
6319
 
6317
6320
      To delete the current view::
6318
6321
 
6319
 
        bzr view --delete
 
6322
        brz view --delete
6320
6323
 
6321
6324
      To disable the current view without deleting it::
6322
6325
 
6323
 
        bzr view --switch off
 
6326
        brz view --switch off
6324
6327
 
6325
6328
      To define a named view and switch to it::
6326
6329
 
6327
 
        bzr view --name view-name file1 dir1 ...
 
6330
        brz view --name view-name file1 dir1 ...
6328
6331
 
6329
6332
      To list a named view::
6330
6333
 
6331
 
        bzr view --name view-name
 
6334
        brz view --name view-name
6332
6335
 
6333
6336
      To delete a named view::
6334
6337
 
6335
 
        bzr view --name view-name --delete
 
6338
        brz view --name view-name --delete
6336
6339
 
6337
6340
      To switch to a named view::
6338
6341
 
6339
 
        bzr view --switch view-name
 
6342
        brz view --switch view-name
6340
6343
 
6341
6344
      To list all views defined::
6342
6345
 
6343
 
        bzr view --all
 
6346
        brz view --all
6344
6347
 
6345
6348
      To delete all views::
6346
6349
 
6347
 
        bzr view --delete --all
 
6350
        brz view --delete --all
6348
6351
    """
6349
6352
 
6350
6353
    _see_also = []
6358
6361
            ),
6359
6362
        Option('name',
6360
6363
            help='Name of the view to define, list or delete.',
6361
 
            type=unicode,
 
6364
            type=text_type,
6362
6365
            ),
6363
6366
        Option('switch',
6364
6367
            help='Name of the view to switch to.',
6365
 
            type=unicode,
 
6368
            type=text_type,
6366
6369
            ),
6367
6370
        ]
6368
6371
 
6470
6473
 
6471
6474
      Remove the branch at repo/trunk::
6472
6475
 
6473
 
        bzr remove-branch repo/trunk
 
6476
        brz remove-branch repo/trunk
6474
6477
 
6475
6478
    """
6476
6479
 
6540
6543
        Option('all', help='Shelve all changes.'),
6541
6544
        'message',
6542
6545
        RegistryOption('writer', 'Method to use for writing diffs.',
6543
 
                       bzrlib.option.diff_writer_registry,
 
6546
                       breezy.option.diff_writer_registry,
6544
6547
                       value_switches=True, enum_switch=False),
6545
6548
 
6546
6549
        Option('list', help='List shelved changes.'),
6553
6556
            writer=None, list=False, destroy=False, directory=None):
6554
6557
        if list:
6555
6558
            return self.run_for_list(directory=directory)
6556
 
        from bzrlib.shelf_ui import Shelver
 
6559
        from .shelf_ui import Shelver
6557
6560
        if writer is None:
6558
 
            writer = bzrlib.option.diff_writer_registry.get()
 
6561
            writer = breezy.option.diff_writer_registry.get()
6559
6562
        try:
6560
6563
            shelver = Shelver.from_args(writer(sys.stdout), revision, all,
6561
6564
                file_list, message, destroy=destroy, directory=directory)
6609
6612
    _see_also = ['shelve']
6610
6613
 
6611
6614
    def run(self, shelf_id=None, action='apply', directory=u'.'):
6612
 
        from bzrlib.shelf_ui import Unshelver
 
6615
        from .shelf_ui import Unshelver
6613
6616
        unshelver = Unshelver.from_args(shelf_id, action, directory=directory)
6614
6617
        try:
6615
6618
            unshelver.run()
6623
6626
    By default, only unknown files, not ignored files, are deleted.  Versioned
6624
6627
    files are never deleted.
6625
6628
 
6626
 
    Another class is 'detritus', which includes files emitted by bzr during
 
6629
    Another class is 'detritus', which includes files emitted by brz during
6627
6630
    normal operations and selftests.  (The value of these files decreases with
6628
6631
    time.)
6629
6632
 
6637
6640
                     Option('detritus', help='Delete conflict files, merge and revert'
6638
6641
                            ' backups, and failed selftest dirs.'),
6639
6642
                     Option('unknown',
6640
 
                            help='Delete files unknown to bzr (default).'),
 
6643
                            help='Delete files unknown to brz (default).'),
6641
6644
                     Option('dry-run', help='Show files to delete instead of'
6642
6645
                            ' deleting them.'),
6643
6646
                     Option('force', help='Do not prompt before deleting.')]
6644
6647
    def run(self, unknown=False, ignored=False, detritus=False, dry_run=False,
6645
6648
            force=False, directory=u'.'):
6646
 
        from bzrlib.clean_tree import clean_tree
 
6649
        from .clean_tree import clean_tree
6647
6650
        if not (unknown or ignored or detritus):
6648
6651
            unknown = True
6649
6652
        if dry_run:
6713
6716
                            ]
6714
6717
 
6715
6718
    def run(self, plugin=None, include_duplicates=False):
6716
 
        from bzrlib.export_pot import export_pot
 
6719
        from .export_pot import export_pot
6717
6720
        export_pot(self.outf, plugin, include_duplicates)
6718
6721
 
6719
6722
 
6721
6724
    # register lazy builtins from other modules; called at startup and should
6722
6725
    # be only called once.
6723
6726
    for (name, aliases, module_name) in [
6724
 
        ('cmd_bundle_info', [], 'bzrlib.bundle.commands'),
6725
 
        ('cmd_config', [], 'bzrlib.config'),
6726
 
        ('cmd_dpush', [], 'bzrlib.foreign'),
6727
 
        ('cmd_version_info', [], 'bzrlib.cmd_version_info'),
6728
 
        ('cmd_resolve', ['resolved'], 'bzrlib.conflicts'),
6729
 
        ('cmd_conflicts', [], 'bzrlib.conflicts'),
6730
 
        ('cmd_ping', [], 'bzrlib.smart.ping'),
6731
 
        ('cmd_sign_my_commits', [], 'bzrlib.commit_signature_commands'),
6732
 
        ('cmd_verify_signatures', [], 'bzrlib.commit_signature_commands'),
6733
 
        ('cmd_test_script', [], 'bzrlib.cmd_test_script'),
 
6727
        ('cmd_bundle_info', [], 'breezy.bundle.commands'),
 
6728
        ('cmd_config', [], 'breezy.config'),
 
6729
        ('cmd_dpush', [], 'breezy.foreign'),
 
6730
        ('cmd_version_info', [], 'breezy.cmd_version_info'),
 
6731
        ('cmd_resolve', ['resolved'], 'breezy.conflicts'),
 
6732
        ('cmd_conflicts', [], 'breezy.conflicts'),
 
6733
        ('cmd_ping', [], 'breezy.smart.ping'),
 
6734
        ('cmd_sign_my_commits', [], 'breezy.commit_signature_commands'),
 
6735
        ('cmd_verify_signatures', [], 'breezy.commit_signature_commands'),
 
6736
        ('cmd_test_script', [], 'breezy.cmd_test_script'),
6734
6737
        ]:
6735
6738
        builtin_command_registry.register_lazy(name, aliases, module_name)