~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005-2011 Canonical Ltd

    gpg,

from bzrlib import (

    symbol_versioning,

    )

    To compare the working directory to a specific revision, pass a

    single revision to the revision argument.

 

    To see which files have changed in a specific revision, or between

    two revisions, pass a revision range to the revision argument.

    This will produce the same results as calling 'bzr diff --summarize'.

 

        b = bzrdir.BzrDir.open_containing_tree_or_branch(directory)[1]

            if len(page_bytes) == 0:

                self.outf.write('(empty)\n');

            else:

                decomp_bytes = zlib.decompress(page_bytes)

                self.outf.write(decomp_bytes)

                self.outf.write('\n')

class cmd_repair_workingtree(Command):

    __doc__ = """Reset the working tree state file.

 

    This is not meant to be used normally, but more as a way to recover from

    filesystem corruption, etc. This rebuilds the working inventory back to a

    'known good' state. Any new modifications (adding a file, renaming, etc)

    will be lost, though modified files will still be detected as such.

 

    Most users will want something more like "bzr revert" or "bzr update"

    unless the state file has become corrupted.

 

    By default this attempts to recover the current state by looking at the

    headers of the state file. If the state file is too corrupted to even do

    that, you can supply --revision to force the state of the tree.

    """

 

    takes_options = ['revision', 'directory',

        Option('force',

               help='Reset the tree even if it doesn\'t appear to be'

                    ' corrupted.'),

    ]

    hidden = True

 

    def run(self, revision=None, directory='.', force=False):

        tree, _ = WorkingTree.open_containing(directory)

        self.add_cleanup(tree.lock_tree_write().unlock)

        if not force:

            try:

                tree.check_state()

            except errors.BzrError:

                pass # There seems to be a real error here, so we'll reset

            else:

                # Refuse

                raise errors.BzrCommandError(

                    'The tree does not appear to be corrupt. You probably'

                    ' want "bzr revert" instead. Use "--force" if you are'

                    ' sure you want to reset the working tree.')

        if revision is None:

            revision_ids = None

        else:

            revision_ids = [r.as_revision_id(tree.branch) for r in revision]

        try:

            tree.reset_state(revision_ids)

        except errors.BzrError, e:

            if revision_ids is None:

                extra = (', the header appears corrupt, try passing -r -1'

                         ' to set the state to the last commit')

            else:

                extra = ''

            raise errors.BzrCommandError('failed to reset the tree state'

                                         + extra)

 

 

            entries = sorted(

                (tree.id2path(file_id), tree.inventory[file_id])

                for file_id in file_ids if tree.has_id(file_id))

    If there is no default location set, the first pull will set it (use

    --no-remember to avoid settting it). After that, you can omit the

    location to use the default.  To change the default, use --remember. The

    value will only be saved if the remote location can be accessed.

    def run(self, location=None, remember=None, overwrite=False,

            # Remembers if asked explicitly or no previous location is set

            if (remember

                or (remember is None and branch_to.get_parent() is None)):

        if getattr(result, 'tag_conflicts', None):

            return 1

        else:

            return 0

    If there is no default push location set, the first push will set it (use

    --no-remember to avoid settting it).  After that, you can omit the

    location to use the default.  To change the default, use --remember. The

    value will only be saved if the remote location can be accessed.

        Option('no-tree',

               help="Don't populate the working tree, even for protocols"

               " that support it."),

    def run(self, location=None, remember=None, overwrite=False,

        stacked=False, strict=None, no_tree=False):

            use_existing_dir=use_existing_dir, no_tree=no_tree)

 

    The synonyms 'clone' and 'get' for this command are deprecated.

        if self.invoked_as in ['get', 'clone']:

            ui.ui_factory.show_user_warning(

                'deprecated_command',

                deprecated_name=self.invoked_as,

                recommended_name='branch',

                deprecated_in_version='2.4')

            no_backup='Don\'t backup changed files.',

                'recovered and even if they are non-empty directories. '

                '(deprecated, use no-backup)')]

        if file_deletion_strategy == 'force':

            note("(The --force option is deprecated, rather use --no-backup "

                "in future.)")

            file_deletion_strategy = 'no-backup'

 

            force=(file_deletion_strategy=='no-backup'))

        self.add_cleanup(b.repository.lock_read().unlock)

        graph = b.repository.get_graph()

        revisions = [revid for revid, parents in

            graph.iter_ancestry([last_revision])]

        for revision_id in reversed(revisions):

            if _mod_revision.is_null(revision_id):

                continue

                '  Append revisions to it only.'),

         Option('no-tree',

                'Create a branch without a working tree.')

            create_prefix=False, no_tree=False):

            if no_tree:

                force_new_tree = False

            else:

                force_new_tree = None

                                   possible_transports=[to_transport],

                                   force_new_tree=force_new_tree)

            if not no_tree:

                a_bzrdir.create_workingtree()

    Note that when using the -r argument with a range of revisions, the

    differences are computed between the two specified revisions.  That

    is, the command does not show the changes introduced by the first 

    revision in the range.  This differs from the interpretation of 

    revision ranges used by "bzr log" which includes the first revision

    in the range.

 

        The changes introduced by revision 2 (equivalent to -r1..2)::

 

            bzr diff -c2

 

        To see the changes introduced by revision X::

        The changes between the current revision and the previous revision

        (equivalent to -c-1 and -r-2..-1)

            bzr diff -r-2..

            short_name='F',

            title='Diff format'),

        self.add_cleanup(tree.lock_read().unlock)

        self.cleanup_now()

            if basis_inv.has_id(file_id):

                   ),

            Option('signatures',

                   help='Show digital signature validity'),

            signatures=False,

        if b.get_config().validate_signatures_in_log():

            signatures = True

 

        if signatures:

            if not gpg.GPGStrategy.verify_signatures_available():

                raise errors.GpgmeNotInstalled(None)

 

            signature=signatures

    :Notes: 

        

    * Ignore patterns containing shell wildcards must be quoted from

      the shell on Unix.

 

    * Ignore patterns starting with "#" act as comments in the ignore file.

      To ignore patterns that begin with that character, use the "RE:" prefix.

        Ignore files whose name begins with the "#" character::

 

            bzr ignore "RE:^#"

 

        but always ignore autosave files ending in ~, even under local/::

    encoding = 'exact'

             Option('lossy', 

                    help='When committing to a foreign version control '

                    'system do not push data that can not be natively '

                    'represented.'),

            author=None, show_diff=False, exclude=None, commit_time=None,

            lossy=False):

            make_commit_message_template_encoded,

            set_commit_message,

                my_message = set_commit_message(commit_obj)

                if my_message is None:

                    start_message = generate_commit_message_template(commit_obj)

                    my_message = edit_commit_message_encoded(text,

                        start_message=start_message)

                        exclude=tree.safe_relpath_files(exclude),

                        lossy=lossy)

                " Please 'bzr add' the files you want to commit, or use"

                " --unchanged to force an empty commit.")

    __doc__ = """Upgrade a repository, branch or working tree to a newer format.

 

    When the default format has changed after a major new release of

    Bazaar, you may be informed during certain operations that you

    should upgrade. Upgrading to a newer format may improve performance

    or make new features available. It may however limit interoperability

    with older repositories or with older versions of Bazaar.

 

    If you wish to upgrade to a particular format rather than the

    current default, that can be specified using the --format option.

    As a consequence, you can use the upgrade command this way to

    "downgrade" to an earlier format, though some conversions are

    a one way process (e.g. changing from the 1.x default to the

    2.x default) so downgrading is not always possible.

 

    A backup.bzr.~#~ directory is created at the start of the conversion

    process (where # is a number). By default, this is left there on

    completion. If the conversion fails, delete the new .bzr directory

    and rename this one back in its place. Use the --clean option to ask

    for the backup.bzr directory to be removed on successful conversion.

    Alternatively, you can delete it by hand if everything looks good

    afterwards.

 

    If the location given is a shared repository, dependent branches

    are also converted provided the repository converts successfully.

    If the conversion of a branch fails, remaining branches are still

    tried.

 

    For more information on upgrades, see the Bazaar Upgrade Guide,

    http://doc.bazaar.canonical.com/latest/en/upgrade-guide/.

    _see_also = ['check', 'reconcile', 'formats']

        RegistryOption('format',

            help='Upgrade to a specific format.  See "bzr help'

                 ' formats" for details.',

            lazy_registry=('bzrlib.bzrdir', 'format_registry'),

            converter=lambda name: bzrdir.format_registry.make_bzrdir(name),

            value_switches=True, title='Branch format'),

        Option('clean',

            help='Remove the backup.bzr directory if successful.'),

        Option('dry-run',

            help="Show what would be done, but don't actually do anything."),

    ]

    def run(self, url='.', format=None, clean=False, dry_run=False):

        exceptions = upgrade(url, format, clean_up=clean, dry_run=dry_run)

        if exceptions:

            if len(exceptions) == 1:

                # Compatibility with historical behavior

                raise exceptions[0]

            else:

                return 3

        if email:

            raise errors.BzrCommandError("--email can only be used to display existing "

                                         "identity")

 

        elif typestring == "memory":

        elif typestring == "fakenfs":

                     ListOption('exclude', type=str, argname="PATTERN",

                                short_name='x',

                                help='Exclude tests that match this regular'

                                ' expression.'),

        if not exclude:

            exclude_pattern = None

        else:

            exclude_pattern = '(' + '|'.join(exclude) + ')'

                          "exclude_pattern": exclude_pattern,

    or the branch most recently merged using --remember.  The source of the

    merge may also be specified in the form of a path to a file in another

    branch:  in this case, only the modifications to that file are merged into

    the current working tree.

 

    When merging from a branch, by default bzr will try to merge in all new

    work from the other branch, automatically determining an appropriate base

    revision.  If this fails, you may need to give an explicit base.

 

    To pick a different ending revision, pass "--revision OTHER".  bzr will

    try to merge in all new work up to and including revision OTHER.

 

    If you specify two values, "--revision BASE..OTHER", only revisions BASE

    through OTHER, excluding BASE but including OTHER, will be merged.  If this

    causes some revisions to be skipped, i.e. if the destination branch does

    not already contain revision BASE, such a merge is commonly referred to as

    a "cherrypick". Unlike a normal merge, Bazaar does not currently track

    cherrypicks. The changes look like a normal commit, and the history of the

    changes from the other branch is not stored in the commit.

 

    Revision numbers are always relative to the source branch.

    If there is no default branch set, the first merge will set it (use

    --no-remember to avoid settting it). After that, you can omit the branch

    to use the default.  To change the default, use --remember. The value will

    only be saved if the remote location can be accessed.

    --force is given.  If --force is given, then the changes from the source 

    will be merged with the current working tree, including any uncommitted

    changes in the tree.  The --force option can also be used to create a

        To merge all new revisions from bzr.dev::

            merge_type=None, show_base=False, reprocess=None, remember=None,

 

        if tree.branch.revno() == 0:

            raise errors.BzrCommandError('Merging into empty branches not currently supported, '

                                         'https://bugs.launchpad.net/bzr/+bug/308562')

            # check if location is a nonexistent file (and not a branch) to

            # disambiguate the 'Nothing to do'

            if merger.interesting_files:

                if not merger.other_tree.has_filename(

                    merger.interesting_files[0]):

                    note("merger: " + str(merger))

                    raise errors.PathsDoNotExist([location])

        if pull and not preview:

        # Remember where we merge from. We need to remember if:

        # - user specify a location (and we don't merge from the parent

        #   branch)

        # - user ask to remember or there is no previous location set to merge

        #   from and user didn't ask to *not* remember

        if (user_location is not None

            and ((remember

                  or (remember is None

                      and tree.branch.get_submit_branch() is None)))):

        # Merge tags (but don't set them in the master branch yet, the user

        # might revert this merge).  Commit will propagate them.

        _merge_tags_if_possible(other_branch, tree.branch, ignore_master=True)

    merge instead.  For example, "merge . -r -2..-3" (don't forget the ".")

    will remove the changes introduced by the second last commit (-2), without

    affecting the changes introduced by the last commit (-1).  To remove

    certain changes on a hunk-by-hunk basis, see the shelve command.

    _see_also = ['cat', 'export', 'merge', 'shelve']

        from bzrlib import plugin

        # Don't give writelines a generator as some codecs don't like that

        self.outf.writelines(

            list(plugin.describe_plugins(show_paths=verbose)))

        from bzrlib.annotate import (

            annotate_file_tree,

            )

        if wt is not None and revision is None:

            annotate_file_tree(tree, file_id, self.outf, long, all,

                show_ids=show_ids, branch=branch)

                    u'Uncommit these revisions',

    Both the submit branch and the public branch follow the usual behavior with

    respect to --remember: If there is no default location set, the first send

    will set it (use --no-remember to avoid settting it). After that, you can

    omit the location to use the default.  To change the default, use

    --remember. The value will only be saved if the location can be accessed.

 

            no_patch=False, revision=None, remember=None, output=None,

            note('Deleted tag %s.' % tag_name)

            note('Created tag %s.' % tag_name)

        RegistryOption('sort',

            lazy_registry=('bzrlib.tag', 'tag_sort_methods')

    def run(self, directory='.', sort=None, show_ids=False, revision=None):

        from bzrlib.tag import tag_sort_methods

        if sort is None:

            sort = tag_sort_methods.get()

        sort(branch, tags)

                except (errors.NoSuchRevision, errors.GhostRevisionsHaveNoRevno):

            raise errors.BzrCommandError("Can't use both --stacked-on and --unstacked")

 

 

    For complicated changes, it is possible to edit the changes in a separate

    editor program to decide what the file remaining in the working copy

    should look like.  To do this, add the configuration option

 

        change_editor = PROGRAM @new_path @old_path

 

    where @new_path is replaced with the path of the new version of the 

    file and @old_path is replaced with the path of the old version of 

    the file.  The PROGRAM should save the new file with the desired 

    contents of the file in the working tree.

        

    _see_also = ['unshelve', 'configuration']