~maxb/bzr-svn/fetch-svn-rev-info-progress-bar

class InvalidSvnBranchPath(BzrError):

    """Error raised when a path was specified that is not a child of or itself

    a valid branch path in the current branching scheme."""

repository layout. See 'bzr help svn-repository-layout' for details."""

 

    def __init__(self, path, layout):

    """

    def is_branch(self, path, project=None):

        """Check whether a location refers to a branch.

        :param path: Path to check.

        """

        raise NotImplementedError

    def is_branch_parent(self, path, project=None):

        """Check whether the specified path is the parent directory of branches.

        The path may not be a branch itself.

        :param path: path to check

        :returns: boolean

        """

    def is_tag_parent(self, path, project=None):

        """Check whether the specified path is the parent directory of tags.

        The path may not be a tag itself.

        :param path: path to check

        :returns: boolean

        """

        raise NotImplementedError

 

    def is_tag(self, path, project=None):

        according to this branching scheme.

 

        :param path: path to check

    def to_lines(self):

        """Generate a list of lines for this branching scheme.

 

            scheme.

        """

        raise NotImplementedError(self.to_lines)

 

 

class ListBranchingScheme(BranchingScheme):

    wildcards."""

    def __init__(self, branch_list, tag_list=[]):

        """Create new ListBranchingScheme instance.

 

    def __str__(self):

        return "list-%s" % prop_name_quote(bz2.compress("".join(map(lambda x:x+"\n", self.branch_list))))

    def is_tag(self, path, project=None):

        """See BranchingScheme.is_tag()."""

        return False

        parts = path.strip("/").split("/")

        for pattern in self.split_branch_list:

            if self._pattern_cmp(parts[:len(pattern)], pattern):

                        "/".join(parts[len(pattern):]))

        raise InvalidSvnBranchPath(path, self)

 

 

 

class NoBranchingScheme(ListBranchingScheme):

    root of the repository."""

    def __init__(self):

        ListBranchingScheme.__init__(self, [""])

 

 

class TrunkBranchingScheme(ListBranchingScheme):

    """

    def __init__(self, level=0):

        self.level = level

 

        if parts[self.level] == "trunk" or parts[self.level] == "hooks":

            return ("/".join(parts[0:self.level]).strip("/"),

                    "/".join(parts[self.level+1:]).strip("/"))

              len(parts) >= self.level+2):

            return ("/".join(parts[0:self.level]).strip("/"),

                    "/".join(parts[self.level+2:]).strip("/"))

        else:

            raise InvalidSvnBranchPath(path, self)

        if not path.startswith(self.path):

            raise InvalidSvnBranchPath(path, self)

 

                path[len(self.path):].strip("/"))

 

    def __str__(self):

 

 

def guess_scheme_from_path(relpath):

    not necessarily a branch path.

 

    :param relpath: Relative path in repository

    return NoBranchingScheme()

 

 

                              relpath=None):

    """Try to determine the best fitting branching scheme.

 

    :param changed_paths: Iterator over (branch_path, changes, revnum, revprops)

        as returned from LogWalker.iter_changes().

    :param last_revnum: Number of entries in changed_paths.

                    scheme as a branch.

             branching scheme instance that best matches but also considers

             relpath a valid branch path.

    """

    try:

        for (revpaths, revnum, revprops) in changed_paths:

            assert isinstance(revpaths, dict)

                      last_revnum)

            if revpaths == {}:

                continue

                scheme_cache[str(scheme)] = scheme

    finally:

        pb.finished()

    entries = potentials.items()

    entries.sort(lambda (a, b), (c, d): d - b)

 

        return NoBranchingScheme()

    if branch_list == TrunkBranchingScheme(0).branch_list:

        return TrunkBranchingScheme(0)

 

 

def scheme_from_layout(layout):

            repository._log.iter_changes(None, last_revnum, max(0, last_revnum-GUESS_SAMPLE_SIZE)), last_revnum, branch_path)

    finally:

        pb.finished()

            (guessed_scheme, scheme))

    return (guessed_scheme, scheme)