~abentley/bzrtools/bzrtools.dev

# Copyright (C) 2004 Aaron Bentley
# <aaron.bentley@utoronto.ca>
#
#    This program is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program; if not, write to the Free Software
#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

__docformat__ = "restructuredtext"
__doc__ = "Exception classes"
import pybaz.errors

def exception_str(exception):
    answer = ""
    if len(str(exception)) > 0:
        answer +="%s" % str(exception)
    elif hasattr(exception, "__class__"):
        answer += exception.__class__.__name__+"\n"
    if answer == "":
        answer = "Unknown exception"
    return answer


class CommandFailed(Exception):
    """Abstract base class.  Raise when a subcommand fails."""
    pass


class CommandFailedWrapper(CommandFailed):
   """
   Raise to cite another exception as a cause of command failure
   """
   def __init__(self, e):
      """
      Initialize with the wrapped type.

      :param e: The exception that caused the command to fail
      """
      self.e=e

   def __str__(self):
      return exception_str(self.e)


class NoVersionLogs(CommandFailed):
    """Raise when commit fails because the tree has no logs for the version"""
    def __init__(self, version):
        """
        Initialize with the version that has no logs in the tree.

        :param version: The version that has no logs in the tree
        :type version: `arch.Version`
        """
        self.version=version

    def __str__(self):
        return "No logs in tree for version \""+str(self.version)+"\"."


class OutOfDate(CommandFailed):
    """Raise when commit fails because the tree is not up to date"""
    def __str__(self):
        return "Tree is not up-to-date"


class EmptyCommit(CommandFailed):
    """Raise when commit fails because the tree contains no changes."""
    def __str__(self):
        return "Aborting empty commit."


class NoLogMessage(CommandFailed):
    """Raise when commit fails because there is no log message."""
    def __str__(self):
        return "No log message available."


class NoLogSummary(CommandFailed):
    """Raise when commit fails because there is no log message."""
    def __str__(self):
        return "Log summary is missing or blank."

class CommitToMirror(CommandFailed):
    """Raise when commit fails because it attempts to write to a mirror."""
    def __init__(self, archive):
        self.archive=archive

    def __str__(self):
        return "Attempt to commit to mirror \""+str(self.archive)+"\"."


class CommitFailed(CommandFailed):
    """Raise when commit fails"""
    def __str__(self):
        return "Unable to commit"


class MissingID(CommandFailed):
    """
    Raise to indicate a missing ID error.
    """
    def __init__(self, err):
        """
        Initialize with base error.

        :param err: The original error that was thrown
        :type err: `arch.util.ExecProblem`
        """
        self.err = err

    def __str__(self):
        return str(self.err.proc.error).rstrip("\n")


class LintFailure(CommandFailed):
    """
    Raise to indicate that some files are 'unrecognized'.
    """
    def __init__(self, err):
        """
        Initialize with lint text.

        :param err: The original error that was thrown
        :type err: `str`
        """
        self.err = err

    def __str__(self):
        return str(self.err).rstrip("\n")


class UncommittedChanges(CommandFailed):
    """Raise when merge fails because the tree has uncommitted changes."""
    def __init__(self, tree):
        """
        Initialize with the tree that has uncommitted changes.

        :param tree: The tree that has uncommitted changes
        :type tree: `arch.WorkingTree`
        """
        self.tree=tree

    def __str__(self):
        return "Project tree \"%s\" has has uncommitted changes." % self.tree


class DirectoryExists(CommandFailed):
    """Raise when get fails because the tree has no logs for the version"""
    def __init__(self, directory):
        """
        Initialize with the directory that exists.

        :param directory: The directory that exists 
        :type directory: str
        """
        self.directory=directory

    def __str__(self):
        return "Can't create directory.  \""+str(self.directory)+\
            "\" already exists."

class NoSuchAlias(CommandFailed):
    """Raise when command fails because there is no such alias"""
    def __init__(self, alias):
        """
        Initialize with the alias that's missing.

        :param alias: The fictional alias
        :type alias: str
        """
        self.alias=alias

    def __str__(self):
        return "No such alias: "+self.alias    


class MergeProblem(Exception):
    """An error occured during merging"""
    def __init__(self):
        message = "An error occured during merging"
        Exception.__init__(self, message)

class CantDetermineArchive(Exception):
    """Raise when no archive can be determined"""
    def __init__(self, spec, explanation):
        if spec is not None:
            spectext = "from \"%s\"" % spec
        else:
            spectext = "with no archive specification"
        message = "Unable to determine archive %s:\n%s" % \
            (spectext, explanation)
        Exception.__init__(self, message)

class CantDetermineVersion(Exception):
    """Raise when no version can be determined"""
    def __init__(self, spec, explain=""):
        """
        Initialize with the spec and optional explanation.

        :param spec: The version specifier that was used
        :type spec: string
        :param explain: An explanation of why the revision specifier didn't work
        :type explain: string
        """
        if spec != None:
            self.spec=spec
        else:
            self.spec=""
        self.explain=explain
    def __str__(self):
        return "Unable to determine version from \""+str(self.spec)+"\".\n"+\
            self.explain


class CantDetermineRevision(Exception):
    """Raise when no revision can be determined"""
    def __init__(self, spec, explain=""):
        """
        Initialize with the spec and optional explanation.

        :param spec: The revision specifier that was used
        :type spec: string
        :param explain: An explanation of why the revision specifier didn't work
        :type explain: string
        """
        if spec != None:
            self.spec=spec
        else:
            self.spec=""
        self.explain=explain
    def __str__(self):
        return "Unable to determine revision from \""+str(self.spec)+"\".\n"+self.explain

class NoLatestRevision(CantDetermineRevision):
    """Two trees have merges in common, but merge sequence differs"""
    def __init__(self, mine, other):
        message = """Neither tree is the unambiguous latest revision
MINE candidiate: %s
OTHER candidate: %s""" % (mine, other)
        Exception.__init__(self, message)
        self.mine = mine
        self.other = other
        self.message = message

    __str__ = Exception.__str__


class UnrelatedTrees(CantDetermineRevision):
    """Two trees have no merges in common"""
    def __init__(self, mine, other):
        message = "No relationship could be found between these trees"
        Exception.__init__(self, message)
        self.mine = mine
        self.other = other

    __str__ = Exception.__str__


class CantParseAlias(Exception):
    "Raise to indicate that alias parsing failed"
    def __init__(self, text):
        self.text=text
    def __str__(self):
        return "Can't parse alias:\""+self.text+"\""

class ForbiddenAliasSyntax(Exception):
    "Raise to indicate that alias name uses forbidden syntax"
    def __init__(self, text):
        self.text=text
    def __str__(self):
        return "Forbidden alias syntax:\""+self.text+"\""


class BadOption(Exception):
    """Raise if a prompting option is set to a bogus value"""
    pass


class NoEditorSpecified(Exception):
    """
    Raise when an editor is requested, but none is available.
    """
    def __str__(self):
        return "No editor specified."


class GetHelp(Exception):
    """Indicate that help is required, not normal command execution"""


class TreeNotContain(Exception):
    """Indicates that tree does not contain a given path.
    """
    def __init__(self, tree, path):
        self.path = path
        self.tree = tree

    def __str__(self):
        return "The tree \"%s\" does not contain \"%s\"." % \
        (self.tree, self.path)


class ArchiveLookupError(Exception):
    """Raise to indicate an error that prevented the lookup from completing
    """
    def __init__(self, exception, arch_name, resource):
        self.exception = exception
        self.arch_name = arch_name
        self.resource = resource

    def __str__(self):
        return "Error encountered looking up \"%s\" at %s.\n%s" % \
            (self.arch_name, self.resource, exception_str(self.exception))


class SubmitError(Exception):
    """Error submitting an archive to an arch registry"""
    def __init__(self, archive, location, registry, result):
        message = """Failed to register location.
Archive: %s
Location: %s
Registry: %s
Result: %s""" % (archive, location, registry, result)
        self.archive = archive
        self.location = location
        self.registry = registry
        self.result = result
        Exception.__init__(self, message)


class NoSuchRevision(Exception):
    """Raise when a required revision does not exist."""
    def __init__(self, revision):
        self.revision=revision

    def __str__(self):
        return "This revision does not exist:\n"+str(self.revision)


class NoVersionRevisions(Exception):
    """The tree has no revisions for the desired version."""
    def __init__(self, tree, version):
        self.tree = tree
        self.version = version

    def __str__(self):
        return "No logs for %s present in tree %s" % (self.version, self.tree)


class WrongArchName(Exception):
    """Attempt to register the archive with the wrong name"""
    def __init__(self, location, right_name, wrong_name):
        self.location = location
        self.right_name = right_name
        self.wrong_name = wrong_name
    def __str__(self):
        return "Attempt to register %s with location %s, but that's really %s" \
            % (self.right_name, self.location, self.wrong_name)

class BlandSubject(CommandFailed):
    """The subject line of an email has no useful information"""
    def __init__(self):
        CommandFailed.__init__(self, "No meaningful subject line")

class NoArchParams(Exception):
    """The user's parameter directory does not exist/cannot be found"""
    def __init__(self, dir):
        self.dir = dir
        message = "Arch parameter directory does not exist\ndir: %s" % dir
        Exception.__init__(self, message)


class InvalidChangeset(Exception):
    """The user's parameter directory does not exist/cannot be found"""
    def __init__(self, dir):
        self.dir = dir
        message = "Directory is not a valid changeset.\ndir: %s" % dir
        Exception.__init__(self, message)


class NotLibrary(Exception):
    """A directory that was not library was spcified as if it was one."""
    def __init__(self, dir):
        self.dir = dir
        message = "Specified directory is not a library.\ndir: %s" % dir
        Exception.__init__(self, message)


class NoGreedy(Exception):
    """A greedy library was required, but not available."""
    def __init__(self, revision):
        self.revision = revision
        message = "No greedy libraries found adding revision.\nrevision: %s" %\
            revision
        Exception.__init__(self, message)

class TreeRootNone(pybaz.errors.TreeRootError):
    """None was supplied instead of a valid tree root"""
    def __init__(self):
        message = "No tree root supplied"
        Exception.__init__(self, message)

class IsAutoAlias(CommandFailed):
    """User attempted to redefine an auto alias"""
    def __init__(self, alias, message=None):
        self.revision = alias
        if message is None:
            message = "\"%s\" is an auto alias." % alias
        Exception.__init__(self, message)

class TarError(Exception):
    """An error occurred using tar"""
    def __init__(self, msg):
        Exception.__init__(self, msg)
    

class UnknownCompressionMethod(TarError):
    """User specified an unknown compression method"""
    def __init__(self, method):
        self.method = method
        msg = "Compression method \"%s\" is unknown." % self.method
        TarError.__init__(self, msg)

class NoUnambiguousParent(TarError):
    """This tarfile doesn't follow the convention of a single root dir"""
    def __init__(self, file, dir):
        self.file = file
        self.dir = dir 
        msg = "The file \"%s\" does not have \"%s\" as a parent" % (self.file, 
                                                                    self.dir)
        TarError.__init__(self, msg)

class UnsupportedScheme(Exception):
    def __init__(self, location):
        msg = "Unsupported scheme: %s" % location
        self.location = location
        Exception.__init__(self, msg)

# arch-tag: fd8812b0-2d93-4b7c-a669-24a915d86ec1