~bzr-pqm/bzr/bzr.dev

# Copyright (C) 2005, 2006, 2007, 2008 Canonical Ltd

from bzrlib import (

    osutils,

    symbol_versioning,

    )

from bzrlib.patches import (

    MalformedHunkHeader,

    MalformedLine,

    MalformedPatchHeader,

    PatchConflict,

    PatchSyntax,

    )

 

    should be displayed with a traceback; if False (or absent) this was

    probably a user or environment error and they don't need the gory details.

    (That can be overridden by -Derror on the command line.)

    by the instance's dict.

        except (AttributeError, TypeError, NameError, ValueError, KeyError), e:

            return 'Unprintable exception %s: dict=%r, fmt=%r, error=%r' \

                % (self.__class__.__name__,

                   self.__dict__,

                   getattr(self, '_fmt', None),

                   e)

            return fmt

        fmt = getattr(self, '__doc__', None)

        if fmt is not None:

            symbol_versioning.warn("%s uses its docstring as a format, "

                    "it should use _fmt instead" % self.__class__.__name__,

                    DeprecationWarning)

            return fmt

        return 'Unprintable exception %s: dict=%r, fmt=%r' \

            % (self.__class__.__name__,

               self.__dict__,

               getattr(self, '_fmt', None),

               )

class BzrNewError(BzrError):

    """Deprecated error base class."""

    # base classes should override the docstring with their human-

    # readable explanation

 

    def __init__(self, *args, **kwds):

        # XXX: Use the underlying BzrError to always generate the args

        # attribute if it doesn't exist.  We can't use super here, because

        # exceptions are old-style classes in python2.4 (but new in 2.5).

        # --bmc, 20060426

        symbol_versioning.warn('BzrNewError was deprecated in bzr 0.13; '

             'please convert %s to use BzrError instead'

             % self.__class__.__name__,

             DeprecationWarning,

             stacklevel=2)

        BzrError.__init__(self, *args)

        for key, value in kwds.items():

            setattr(self, key, value)

 

    def __str__(self):

        try:

            # __str__() should always return a 'str' object

            # never a 'unicode' object.

            s = self.__doc__ % self.__dict__

            if isinstance(s, unicode):

                return s.encode('utf8')

            return s

        except (TypeError, NameError, ValueError, KeyError), e:

            return 'Unprintable exception %s(%r): %r' \

                % (self.__class__.__name__,

                   self.__dict__, e)

 

 

        "record_entry_contents.")

    def __init__(self, url, extra):

    internal_error = True

    _fmt = 'Not a branch: "%(path)s".'

    def __init__(self, path):

       self.path = urlutils.unescape_for_display(path, 'ascii')

class FileInWrongBranch(BzrError):

 

    _fmt = 'File "%(path)s" is not in branch %(branch_base)s.'

 

    def __init__(self, branch, path):

        BzrError.__init__(self)

        self.branch = branch

        self.branch_base = branch.base

        self.path = path

 

 

        which should be in a user friendly form.

        which could explain why this is expected to not be versioned.

        which should be in a user friendly form.

        which could explain why this is expected to be versioned.

    def __init__(self, message):

        # Python 2.5 uses a slot for StandardError.message,

        # so use a different variable name.  We now work around this in

        # BzrError.__str__, but this member name is kept for compatability.

        self.msg = message

    # TODO: show full url for lock, combining the transport and relative

    # bits?

    _fmt = ("Requested revision: %(spec)r does not exist in branch:"

            " %(branch)s%(extra)s")

class HistoryMissing(BzrError):

 

    _fmt = "%(branch)s is missing %(object_type)s {%(object_id)s}"

 

 

class AmbiguousBase(BzrError):

 

    def __init__(self, bases):

        warn("BzrError AmbiguousBase has been deprecated as of bzrlib 0.8.",

                DeprecationWarning)

        msg = ("The correct base is unclear, because %s are all equally close"

                % ", ".join(bases))

        BzrError.__init__(self, msg)

        self.bases = bases

 

 

            " %(master)s.")

    _fmt = "Parents are mismatched between two revisions. %(message)s"

    _fmt = "Text did not match it's checksum: %(message)s"

    _fmt = "Text did not match its checksum: %(message)s"

    _fmt = "Invalid http response for %(path)s: %(msg)s"

        if filename is None:

            filename = ""

        message = "Error(s) parsing config file %s:\n%s" % \

            (filename, ('\n'.join(e.msg for e in errors)))

        BzrError.__init__(self, message)

    _fmt = 'Failed to gpg sign data with command "%(command_line)s"'

class MalformedTransform(BzrError):

    _fmt = "Could not move %(from_path)s%(operator)s %(to_path)s%(extra)s"

            self.extra = ': ' + str(extra)

            self.extra = ''

    _fmt = "Could not rename %(from_path)s%(operator)s %(to_path)s%(extra)s"

class BzrRemoveChangedFilesError(BzrError):

    """Used when user is trying to remove changed files."""

 

    _fmt = ("Can't safely remove modified or unknown files:\n"

        "%(changes_as_text)s"

        "Use --keep to not delete them, or --force to delete them regardless.")

 

    def __init__(self, tree_delta):

        BzrError.__init__(self)

        self.changes_as_text = tree_delta.get_changes_as_text()

        #self.paths_as_string = '\n'.join(changed_files)

        #self.paths_as_string = '\n'.join([quotefn(p) for p in changed_files])

 

    _fmt = "Parameter $(param)s is required but not present."

class DependencyNotPresent(BzrError):

 

    _fmt = 'Unable to import library "%(library)s": %(error)s'

 

    def __init__(self, library, error):

        BzrError.__init__(self, library=library, error=error)

 

 

        self.repo_path = repo.bzrdir.root_transport.base

      - ErrorFromSmartServer was uncaught.  This is logic error in the client

        and so should provoke a traceback to the user.

      - ErrorFromSmartServer was caught but its error_tuple could not be

        translated.  This is probably because the server sent us garbage, and

        should not provoke a traceback.

        self.name = name

class UnknownMailClient(BzrError):

 

    _fmt = "Unknown mail client: %(mail_client)s"

 

    def __init__(self, mail_client):

        BzrError.__init__(self, mail_client=mail_client)

 

 

        display_url = urlutils.unescape_for_display(bzrdir.root_transport.base,

        display_url = urlutils.unescape_for_display(

            tree.bzrdir.root_transport.base, 'ascii')

        self.user_encoding = osutils.get_user_encoding()