/brz/remove-bazaar

 

"""builtin brz commands"""

 

import errno

import os

import sys

    if revisions is None:

        return None

    if len(revisions) != 1:

            'brz %s --revision takes exactly one revision identifier') % (

                command_name,))

    return revisions[0]

        from .status import show_tree_status

 

        if revision and len(revision) > 2:

                gettext('brz status --revision takes exactly'

                        ' one or two revision specifiers'))

 

    @display_command

    def run(self, revision_id=None, revision=None, directory=u'.'):

        if revision_id is not None and revision is not None:

                                                 ' revision_id or --revision'))

        if revision_id is None and revision is None:

                gettext('You must supply either --revision or a revision_id'))

 

        b = controldir.ControlDir.open_containing_tree_or_branch(directory)[1]

 

        revisions = getattr(b.repository, "revisions", None)

        if revisions is None:

                gettext('Repository %r does not support '

                        'access to raw revision texts') % b.repository)

 

                    msg = gettext(

                        "The repository {0} contains no revision {1}.").format(

                            b.repository.base, revision_id.decode('utf-8'))

            elif revision is not None:

                for rev in revision:

                    if rev is None:

                            gettext('You cannot specify a NULL revision.'))

                    rev_id = rev.as_revision_id(b)

                    self.print_revision(revisions, rev_id)

            try:

                working = d.open_workingtree()

            except errors.NoWorkingTree:

                    gettext("No working tree to remove"))

            except errors.NotLocalUrl:

                    gettext("You cannot remove the working tree"

                            " of a remote path"))

            if not force:

                    raise errors.ShelvedChanges(working)

 

            if working.user_url != working.branch.user_url:

                    gettext("You cannot remove the working tree"

                            " from a lightweight checkout"))

 

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

            else:

                # Refuse

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

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

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

                                '-r -1 to set the state to the last commit')

            else:

                extra = ''

                gettext('failed to reset the tree state{0}').format(extra))

 

 

    @display_command

    def run(self, tree=False, location=u'.', revision=None):

        if revision is not None and tree:

                gettext("--tree and --revision can not be used together"))

 

        if tree:

            self.enter_context(b.lock_read())

            if revision:

                if len(revision) != 1:

                        "Revision numbers only make sense for single "

                        "revisions, not ranges"))

                revid = revision[0].as_revision_id(b)

    def run(self, revision=None, show_ids=False, kind=None, include_root=False,

            file_list=None):

        if kind and kind not in ['file', 'directory', 'symlink']:

                gettext('invalid kind %r specified') % (kind,))

 

        revision = _get_one_revision('inventory', revision)

        if names_list is None:

            names_list = []

        if len(names_list) < 2:

        tree, rel_names = WorkingTree.open_containing_paths(

            names_list, canonicalize=False)

        for file_name in rel_names[0:-1]:

            if file_name == '':

                    gettext("can not copy root of branch"))

        self.enter_context(tree.lock_tree_write())

        into_existing = osutils.isdir(names_list[-1])

            try:

                (src, dst) = rel_names

            except IndexError:

                    gettext('to copy multiple files the'

                            ' destination must be a versioned'

                            ' directory'))

            try:

                src_kind = tree.stored_kind(src)

            except errors.NoSuchFile:

                    gettext('Could not copy %s => %s: %s is not versioned.')

                    % (src, dst, src))

            if src_kind is None:

                    gettext('Could not copy %s => %s . %s is not versioned\\.'

                            % (src, dst, src)))

            if src_kind == 'directory':

                    gettext('Could not copy %s => %s . %s is a directory.'

                            % (src, dst, src)))

            dst_parent = osutils.split(dst)[0]

                try:

                    dst_parent_kind = tree.stored_kind(dst_parent)

                except errors.NoSuchFile:

                        gettext('Could not copy %s => %s: %s is not versioned.')

                        % (src, dst, dst_parent))

                if dst_parent_kind != 'directory':

                        gettext('Could not copy to %s: %s is not a directory.')

                        % (dst_parent, dst_parent))

 

        if auto:

            return self.run_auto(names_list, after, dry_run)

        elif dry_run:

        if names_list is None:

            names_list = []

        if len(names_list) < 2:

        tree, rel_names = WorkingTree.open_containing_paths(

            names_list, canonicalize=False)

        for file_name in rel_names[0:-1]:

            if file_name == '':

                    gettext("can not move root of branch"))

        self.enter_context(tree.lock_tree_write())

        self._run(tree, names_list, rel_names, after)

 

    def run_auto(self, names_list, after, dry_run):

        if names_list is not None and len(names_list) > 1:

                gettext('Only one path may be specified to --auto.'))

        if after:

                gettext('--after cannot be specified with --auto.'))

        work_tree, file_list = WorkingTree.open_containing_paths(

            names_list, default_directory='.')

                    self.outf.write("%s => %s\n" % (src, dest))

        else:

            if len(names_list) != 2:

                                                     ' destination must be a versioned'

                                                     ' directory'))

 

        stored_loc = branch_to.get_parent()

        if location is None:

            if stored_loc is None:

                                                     " specified."))

            else:

                display_url = urlutils.unescape_for_display(stored_loc,

        revision = _get_one_revision('pull', revision)

        if mergeable is not None:

            if revision is not None:

                    'Cannot use -r with merge directives or bundles'))

            mergeable.install_revisions(branch_to.repository)

            base_revision_id, revision_id, verified = \

                    # error by the feedback given to them. RBC 20080227.

                    stacked_on = parent_url

            if not stacked_on:

                    "Could not determine branch to refer to."))

 

        # Get the destination location

            if stored_loc is None:

                parent_loc = br_from.get_parent()

                if parent_loc:

                        "No push location known or specified. To push to the "

                        "parent branch (at %s), use 'brz push :parent'." %

                        urlutils.unescape_for_display(parent_loc,

                                                      self.outf.encoding)))

                else:

                        "No push location known or specified."))

            else:

                display_url = urlutils.unescape_for_display(stored_loc,

    parameter, as in "branch foo/bar -r 5".

    """

 

    _see_also = ['checkout']

    takes_args = ['from_location', 'to_location?']

    takes_options = ['revision',

                            help="Bind new branch to from location."),

                     Option('no-recurse-nested',

                            help='Do not recursively check out nested trees.'),

                     ]

 

    def run(self, from_location, to_location=None, revision=None,

            hardlink=False, stacked=False, standalone=False, no_tree=False,

            use_existing_dir=False, switch=False, bind=False,

        from breezy import switch as _mod_switch

        accelerator_tree, br_from = controldir.ControlDir.open_tree_or_branch(

        if no_recurse_nested:

            recurse = 'none'

        else:

                    to_transport)

            except errors.NotBranchError:

                if not use_existing_dir:

                                                         'already exists.') % to_location)

                else:

                    to_dir = None

                else:

                    raise errors.AlreadyBranchError(to_location)

        except errors.NoSuchFile:

                                         % to_location)

        else:

            to_dir = None

                to_transport.delete_tree('.')

                msg = gettext("The branch {0} has no revision {1}.").format(

                    from_location, revision)

        else:

            try:

                to_repo = to_dir.open_repository()

        if recursive:

            t = transport.get_transport(location, purpose='read')

            if not t.listable():

                    "Can't scan this type of location.")

            for b in controldir.ControlDir.find_branches(t):

                self.outf.write("%s\n" % urlutils.unescape_for_display(

                               accelerator_tree, hardlink)

 

 

class cmd_renames(Command):

    __doc__ = """Show list of renamed files.

    """

 

    def run(self, dir=None, revision=None, show_base=None):

        if revision is not None and len(revision) != 1:

                "brz update --revision takes exactly one revision"))

        if dir is None:

            tree = WorkingTree.open_containing('.')[0]

            tree, relpath = WorkingTree.open_containing(dir)

            if relpath:

                # See bug 557886.

                    "brz update can only update a whole tree, "

                    "not a file or subdirectory"))

        branch = tree.branch

                old_tip=old_tip,

                show_base=show_base)

        except errors.NoSuchRevision as e:

                "branch has no revision %s\n"

                "brz update --revision only works"

                " for a revision in the branch history")

                                      specific_files=file_list).added

            file_list = sorted([f.path[1] for f in added], reverse=True)

            if len(file_list) == 0:

        elif file_list is None:

            # missing files show up in iter_changes(basis) as

            # versioned-with-no-kind.

            to_transport.ensure_base()

        except errors.NoSuchFile:

            if not create_prefix:

                                                     " does not exist."

                                                     "\nYou may supply --create-prefix to create all"

                                                     " leading parent directories.")

            try:

                branch.set_append_revisions_only(True)

            except errors.UpgradeRequired:

                                                     ' to append-revisions-only.  Try --default.'))

        if not is_quiet():

            from .info import describe_layout, describe_format

        elif u':' in prefix:

            old_label, new_label = prefix.split(u":")

        else:

                '--prefix expects two values separated by a colon'

                ' (eg "old/:new/")'))

 

        if revision and len(revision) > 2:

                                                 ' one or two revision specifiers'))

 

        if using is not None and format is not None:

                '{0} and {1} are mutually exclusive').format(

                '--using', '--format'))

 

        return int(limitstring)

    except ValueError:

        msg = gettext("The limit argument must be an integer.")

 

 

def _parse_levels(s):

        return int(s)

    except ValueError:

        msg = gettext("The levels argument must be an integer.")

 

 

class cmd_log(Command):

            include_merged = False

        if (exclude_common_ancestry

                and (revision is None or len(revision) != 2)):

                '--exclude-common-ancestry requires -r with two revisions'))

        if include_merged:

            if levels is None:

                levels = 0

            else:

                    '{0} and {1} are mutually exclusive').format(

                    '--levels', '--include-merged'))

 

            if len(change) > 1:

                raise errors.RangeInChangeOption()

            if revision is not None:

                    '{0} and {1} are mutually exclusive').format(

                    '--revision', '--change'))

            else:

                revision = change

 

        filter_by_dir = False

        if file_list:

            # find the file ids to log and check for directory filtering

            b, file_info_list, rev1, rev2 = _get_info_for_log_files(

                revision, file_list, self._exit_stack)

                        "Path unknown at end or start of revision range: %s") %

                        relpath)

                # If the relpath is the top of the tree, we log everything

                if relpath == '':

                    break

                else:

                filter_by_dir = filter_by_dir or (

                    kind in ['directory', 'tree-reference'])

        else:

            delta_type = 'full'

        if not show_diff:

            diff_type = None

            diff_type = 'partial'

        else:

            diff_type = 'full'

        # original algorithm - per-file-graph - for the "single

        # file that isn't a directory without showing a delta" case.

        partial_history = revision and b.repository._format.supports_chks

                              or delta_type or partial_history)

 

        match_dict = {}

            match_dict['bugs'] = match_bugs

 

        # Build the LogRequest and execute it

        rqst = make_log_request_dict(

            start_revision=rev1, end_revision=rev2, limit=limit,

            message_search=message, delta_type=delta_type,

            diff_type=diff_type, _match_using_deltas=match_using_deltas,

            # b is taken from revision[0].get_branch(), and

            # show_log will use its revision_history. Having

            # different branches will lead to weird behaviors.

                "brz %s doesn't accept two revisions in different"

                " branches.") % command_name)

        if start_spec.spec is None:

        else:

            rev2 = end_spec.in_history(branch)

    else:

            'brz %s --revision takes one or two values.') % command_name)

    return rev1, rev2

 

            null=False, kind=None, show_ids=False, path=None, directory=None):

 

        if kind and kind not in ('file', 'directory', 'symlink', 'tree-reference'):

 

        if verbose and null:

                gettext('Cannot set both --verbose and --null'))

        all = not (unknown or versioned or ignored)

 

            fs_path = '.'

        else:

            if from_root:

                                                     ' and PATH'))

            fs_path = path

        tree, branch, relpath = \

                self.outf.write("%s\n" % pattern)

            return

        if not name_pattern_list:

                                                 "NAME_PATTERN or --default-rules."))

        name_pattern_list = [globbing.normalize_pattern(p)

                             for p in name_pattern_list]

        for name_pattern in name_pattern_list:

            if (name_pattern[0] == '/' or

                    (len(name_pattern) > 1 and name_pattern[1] == ':')):

                    "NAME_PATTERN should not be an absolute path"))

        tree, relpath = WorkingTree.open_containing(directory)

        ignores.tree_ignores_add_patterns(tree, name_pattern_list)

        try:

            revno = int(revno)

        except ValueError:

                                         % revno)

        revid = WorkingTree.open_containing(

            directory)[0].branch.get_rev_id(revno)

 

        if uncommitted:

            if tree is None:

                    gettext("--uncommitted requires a working tree"))

            export_tree = tree

        else:

            export(export_tree, dest, format, root, subdir,

                   per_file_timestamps=per_file_timestamps)

        except errors.NoSuchExportFormat as e:

                gettext('Unsupported export format: %s') % e.format)

 

 

    def run(self, filename, revision=None, name_from_revision=False,

            filters=False, directory=None):

        if revision is not None and len(revision) != 1:

                                                 " one revision specifier"))

        tree, branch, relpath = \

            _open_directory_or_containing_tree_or_branch(filename, directory)

        if name_from_revision:

            # Try in revision if requested

            if not rev_tree.is_versioned(relpath):

                    "{0!r} is not present in revision {1}").format(

                        filename, rev_tree.get_revision_id()))

            rev_tree_path = relpath

            if rev_tree_path is None:

                # Path didn't exist in working tree

                if not rev_tree.is_versioned(relpath):

                        "{0!r} is not present in revision {1}").format(

                            filename, rev_tree.get_revision_id()))

                else:

                    default_bugtracker = branch_config.get(

                        "bugtracker")

                if default_bugtracker is None:

                        "No tracker specified for bug %s. Use the form "

                        "'tracker:id' or specify a default bug tracker "

                        "using the `bugtracker` option.\nSee "

                tag = default_bugtracker

                bug_id = tokens[0]

            elif len(tokens) != 2:

                    "Invalid bug %s. Must be in the form of 'tracker:id'. "

                    "See \"brz help bugs\" for more information on this "

                    "feature.\nCommit refused.") % bug)

            try:

                yield bugtracker.get_bug_url(tag, branch, bug_id), status

            except bugtracker.UnknownBugTrackerAbbreviation:

                    'Unrecognized bug %s. Commit refused.') % bug)

            except bugtracker.MalformedBugIdentifier as e:

                    u"%s\nCommit refused.") % (e,))

 

    def run(self, message=None, file=None, verbose=False, selected_list=None,

            try:

                commit_stamp, offset = timestamp.parse_patch_date(commit_time)

            except ValueError as e:

                    "Could not parse --commit-time: " + str(e)))

 

        properties = {}

                message = message.replace('\r\n', '\n')

                message = message.replace('\r', '\n')

            if file:

                    "please specify either --message or --file"))

 

        def get_message(commit_obj):

                    my_message = edit_commit_message_encoded(text,

                                                             start_message=start_message)

                if my_message is None:

                                                         " message with either --message or --file"))

                if my_message == "":

                                                         " Please specify a commit message with either"

                                                         " --message or --file or leave a blank message"

                                                         " with --message \"\"."))

                        exclude=tree.safe_relpath_files(exclude),

                        lossy=lossy)

        except PointlessCommit:

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

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

        except ConflictsInTree:

                                                 'tree.  Use "brz conflicts" to list, "brz resolve FILE" to'

                                                 ' resolve.'))

        except StrictCommitFailed:

                                                 " unknown files in the working tree."))

        except errors.BoundBranchOutOfDate as e:

            e.extra_help = (gettext("\n"

            return

 

        if email:

                                                 "identity"))

 

        # display a warning if an email address isn't included in the given name.

 

    def remove_alias(self, alias_name):

        if alias_name is None:

                'brz alias --remove expects an alias to remove.'))

        # If alias is not found, print something like:

        # unalias: foo: not found

            return test_server.FakeNFSServer

        msg = "No known transport type %s. Supported types are: sftp\n" %\

            (typestring)

 

    hidden = True

    takes_args = ['testspecs*']

 

        try:

            from . import tests

                                         "breezy tests to run the breezy testsuite.")

 

        if testspecs_list is not None:

            try:

                from .tests import SubUnitBzrRunnerv1

            except ImportError:

                    "subunit not available. subunit needs to be installed "

                    "to use --subunit."))

            self.additional_selftest_args['runner_class'] = SubUnitBzrRunnerv1

            try:

                from .tests import SubUnitBzrRunnerv2

            except ImportError:

                    "subunit not available. subunit "

                    "needs to be installed to use --subunit2."))

            self.additional_selftest_args['runner_class'] = SubUnitBzrRunnerv2

            self.additional_selftest_args.setdefault(

                'suite_decorators', []).append(parallel)

        if benchmark:

                "--benchmark is no longer supported from brz 2.2; "

                "use bzr-usertest instead"))

        test_suite_factory = None

 

        tree = WorkingTree.open_containing(directory)[0]

        if tree.branch.last_revision() == _mod_revision.NULL_REVISION:

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

 

        # die as quickly as possible if there are uncommitted changes

                mergeable = None

            else:

                if uncommitted:

                                                         ' with bundles or merge directives.'))

 

                if revision is not None:

                        'Cannot use -r with merge directives or bundles'))

                merger, verified = _mod_merge.Merger.from_mergeable(tree,

                                                                    mergeable)

 

        if merger is None and uncommitted:

            if revision is not None and len(revision) > 0:

                                                     ' --revision at the same time.'))

            merger = self.get_merger_from_uncommitted(tree, location, None)

            allow_pending = False

            return 0

        if pull and not preview:

            if merger.interesting_files is not None:

                    gettext('Cannot pull individual files'))

            if (merger.base_rev_id == tree.last_revision()):

                result = tree.pull(merger.other_branch, False,

                result.report(self.outf)

                return 0

        if merger.this_basis is None:

                "This branch has no commits."

                " (perhaps you would prefer 'brz pull')"))

        if preview:

    def sanity_check_merger(self, merger):

        if (merger.show_base and

                merger.merge_type is not _mod_merge.Merge3Merger):

                                                 " merge type. %s") % merger.merge_type)

        if merger.reprocess is None:

            if merger.show_base:

                # Use reprocess if the merger supports it

                merger.reprocess = merger.merge_type.supports_reprocess

        if merger.reprocess and not merger.merge_type.supports_reprocess:

                                                 " for merge type %s.") %

                                         merger.merge_type)

        if merger.reprocess and merger.show_base:

                                                 " show base."))

 

        if (merger.merge_type.requires_file_merge_plan and

             not getattr(merger.other_tree, 'plan_file_merge', None) or

             (merger.base_tree is not None and

                 not getattr(merger.base_tree, 'plan_file_merge', None)))):

                gettext('Plan file merge unsupported: '

                        'Merge type incompatible with tree formats.'))

 

            stored_location_type = "parent"

        mutter("%s", stored_location)

        if stored_location is None:

                gettext("No location specified or remembered"))

        display_url = urlutils.unescape_for_display(stored_location, 'utf-8')

        note(gettext("{0} remembered {1} location {2}").format(verb_string,

        self.enter_context(tree.lock_write())

        parents = tree.get_parent_ids()

        if len(parents) != 2:

                gettext("Sorry, remerge only works after normal"

                        " merges.  Not cherrypicking or multi-merges."))

        interesting_files = None

        if other_branch is None:

            other_branch = parent

            if other_branch is None:

                                                     " or specified."))

            display_url = urlutils.unescape_for_display(parent,

                                                        self.outf.encoding)

 

    def run(self, revision_id_list=None, revision=None, directory=u'.'):

        if revision_id_list is not None and revision is not None:

                gettext('You can only supply one of revision_id or --revision'))

        if revision_id_list is None and revision is None:

                gettext('You must supply either --revision or a revision_id'))

        b = WorkingTree.open_containing(directory)[0].branch

        self.enter_context(b.lock_write())

                if to_revid is None:

                    to_revno = b.revno()

                if from_revno is None or to_revno is None:

                        gettext('Cannot sign a range of non-revision-history revisions'))

                with WriteGroup(b.repository):

                    for revno in range(from_revno, to_revno + 1):

                        b.repository.sign_revision(b.get_rev_id(revno),

                                                   gpg_strategy)

            else:

                    gettext('Please supply either one revision, or a range.'))

 

 

            try:

                location = b.get_old_bound_location()

            except errors.UpgradeRequired:

                    gettext('No location supplied.  '

                            'This format does not remember old locations.'))

            else:

                if location is None:

                    if b.get_bound_location() is not None:

                            gettext('Branch is already bound'))

                    else:

                            gettext('No location supplied'

                                    ' and no previous location known'))

        b_other = Branch.open(location)

        try:

            b.bind(b_other)

        except errors.DivergedBranches:

                gettext('These branches have diverged.'

                        ' Try merging, and then bind again.'))

        if b.get_config().has_explicit_nickname():

    def run(self, directory=u'.'):

        b, relpath = Branch.open_containing(directory)

        if not b.unbind():

 

 

class cmd_uncommit(Command):

        containing_tree = WorkingTree.open_containing(parent_dir)[0]

        repo = containing_tree.branch.repository

        if not repo.supports_rich_root():

                "Can't join trees because %s doesn't support rich root data.\n"

                "You can use brz upgrade on the repository.")

                % (repo,))

            except BadReferenceTarget as e:

                # XXX: Would be better to just raise a nicely printable

                # exception from the real origin.  Also below.  mbp 20070306

                    gettext("Cannot join {0}.  {1}").format(tree, e.reason))

        else:

            try:

                containing_tree.subsume(sub_tree)

            except errors.BadSubsumeSource as e:

                    gettext("Cannot join {0}.  {1}").format(tree, e.reason))

 

 

        if submit_branch is None:

            submit_branch = branch.get_parent()

        if submit_branch is None:

                gettext('No submit branch specified or known'))

 

        stored_public_branch = branch.get_public_branch()

            # FIXME: Should be done only if we succeed ? -- vila 2012-01-03

            branch.set_public_branch(public_branch)

        if not include_bundle and public_branch is None:

                gettext('No public branch specified or known'))

        base_revision_id = None

        if revision is not None:

            if len(revision) > 2:

                    gettext('brz merge-directive takes '

                            'at most two one revision identifiers'))

            revision_id = revision[-1].as_revision_id(branch)

            revision_id = branch.last_revision()

        revision_id = ensure_null(revision_id)

        if revision_id == NULL_REVISION:

        directive = merge_directive.MergeDirective2.from_objects(

            branch.repository, revision_id, time.time(),

            osutils.local_time_offset(), submit_branch,

        self.enter_context(branch.lock_write())

        if delete:

            if tag_name is None:

                    gettext("No tag specified to delete."))

            branch.tags.delete_tag(tag_name)

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

        else:

            if revision:

                if len(revision) != 1:

                        "Tags can only be placed on a single revision, "

                        "not on a range"))

                revision_id = revision[0].as_revision_id(branch)

            if tag_name is None:

                tag_name = branch.automatic_tag_name(revision_id)

                if tag_name is None:

                        "Please specify a tag name."))

            try:

                existing_target = branch.tags.lookup_tag(tag_name)

            stacked_on=None, unstacked=None):

        directory = controldir.ControlDir.open(location)

        if stacked_on and unstacked:

                gettext("Can't use both --stacked-on and --unstacked"))

        elif stacked_on is not None:

            reconfigure.ReconfigureStackedOn().apply(directory, stacked_on)

            if stacked_on or unstacked:

                return

            else:

                                                     'specified'))

        reconfiguration = None

        if tree_type == 'branch':

        possible_transports = [control_dir.root_transport]

        if to_location is None:

            if revision is None:

                                                     ' revision or a location'))

            to_location = tree_location

        try:

            possible_transports.append(branch.user_transport)

        if create_branch:

            if branch is None:

                    gettext('cannot create branch without source branch'))

            to_location = lookup_new_sibling_branch(

                control_dir, to_location,

                          store_uncommitted=store,

                          possible_transports=possible_transports)

        except controldir.BranchReferenceLoop:

                gettext('switching would create a branch reference loop. '

                        'Use the "bzr up" command to switch to a '

                        'different revision.'))

            name = current_view

        if delete:

            if file_list:

                    "Both --delete and a file list specified"))

            elif switch:

                    "Both --delete and --switch specified"))

            elif all:

                tree.views.set_view_info(None, {})

                self.outf.write(gettext("Deleted all views.\n"))

            elif name is None:

                    gettext("No current view to delete"))

            else:

                tree.views.delete_view(name)

                self.outf.write(gettext("Deleted '%s' view.\n") % name)

        elif switch:

            if file_list:

                    "Both --switch and a file list specified"))

            elif all:

                    "Both --switch and --all specified"))

            elif switch == 'off':

                if current_view is None:

                        gettext("No current view to disable"))

                tree.views.set_view_info(None, view_dict)

                self.outf.write(gettext("Disabled '%s' view.\n") %

                # No name given and no current view set

                name = 'my'

            elif name == 'off':

                    "Cannot change the 'off' pseudo view"))