:param section: Section we want to retrieve value from

        :param name: Name of configuration we want to retrieve

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        raise NotImplementedError

    def get_user_name(self, config_file=None):

        """

        Returns user's name from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        raise NotImplementedError

    def get_user_email(self, config_file=None):

        """

        Returns user's email from global configuration file.

        :param config_file: A path to file which should be used to retrieve

          configuration from (might also be a list of file paths)

        """

        raise NotImplementedError

    # =========== #

    # WORKDIR API #

    # =========== #

    @LazyProperty

    def workdir(self):

        """

        Returns ``Workdir`` instance for this repository.

        """

        raise NotImplementedError

class BaseChangeset(object):

    """

    Each backend should implement it's changeset representation.

    **Attributes**

        ``repository``

            repository object within which changeset exists

        ``id``

            may be ``raw_id`` or i.e. for mercurial's tip just ``tip``

        ``raw_id``

            raw changeset representation (i.e. full 40 length sha for git

            backend)

        ``short_id``

            shortened (if apply) version of ``raw_id``; it would be simple

            shortcut for ``raw_id[:12]`` for git/mercurial backends or same

            as ``raw_id`` for subversion

        ``revision``

            revision number as integer

        ``files``

            list of ``FileNode`` (``Node`` with NodeKind.FILE) objects

        ``dirs``

            list of ``DirNode`` (``Node`` with NodeKind.DIR) objects

        ``nodes``

            combined list of ``Node`` objects

        ``author``

            author of the changeset, as unicode

        ``message``

            message of the changeset, as unicode

        ``parents``

            list of parent changesets

        ``last``

            ``True`` if this is last changeset in repository, ``False``

            otherwise; trying to access this attribute while there is no

            changesets would raise ``EmptyRepositoryError``

    """

    def __str__(self):

        return '<%s at %s:%s>' % (self.__class__.__name__, self.revision,

            self.short_id)

    def __repr__(self):

        return self.__str__()

    def __unicode__(self):

        return u'%s:%s' % (self.revision, self.short_id)

    def __eq__(self, other):

        return self.raw_id == other.raw_id

    def __json__(self, with_file_list=False):

        if with_file_list:

            return dict(

                short_id=self.short_id,

                raw_id=self.raw_id,

                revision=self.revision,

                message=self.message,

                date=self.date,

                author=self.author,

                added=[safe_unicode(el.path) for el in self.added],

                changed=[safe_unicode(el.path) for el in self.changed],

                removed=[safe_unicode(el.path) for el in self.removed],

            )

        else:

            return dict(

                short_id=self.short_id,

                raw_id=self.raw_id,

                revision=self.revision,

                message=self.message,

                date=self.date,

                author=self.author,

            )

    @LazyProperty

    def last(self):

        if self.repository is None:

            raise ChangesetError("Cannot check if it's most recent revision")

        return self.raw_id == self.repository.revisions[-1]

    @LazyProperty

    def parents(self):

        """

        Returns list of parents changesets.

        """

        raise NotImplementedError

    @LazyProperty

    def children(self):

        """

        Returns list of children changesets.

        """

        raise NotImplementedError

    @LazyProperty

    def id(self):

        """

        Returns string identifying this changeset.

        """

        raise NotImplementedError

    @LazyProperty

    def raw_id(self):

        """

        Returns raw string identifying this changeset.

        """

        raise NotImplementedError

    @LazyProperty

    def short_id(self):

        """

        Returns shortened version of ``raw_id`` attribute, as string,

        identifying this changeset, useful for web representation.

        """

        raise NotImplementedError

    @LazyProperty

    def revision(self):

        """

        Returns integer identifying this changeset.

        """

        raise NotImplementedError

    @LazyProperty

    def committer(self):

        """

        Returns Committer for given commit

        """

        raise NotImplementedError

    @LazyProperty

    def committer_name(self):

        """

        Returns Author name for given commit

        """

        return author_name(self.committer)

    @LazyProperty

    def committer_email(self):

        """

        Returns Author email address for given commit

        """

    def __getslice__(self, i, j):

        for p in self.current_paths[i:j]:

            yield self.cs.get_node(p)

    def __len__(self):

        return len(self.current_paths)

    def __iter__(self):

        for p in self.current_paths:

            yield self.cs.get_node(p)

class AddedFileNodesGenerator(NodeGeneratorBase):

    """

    Class holding Added files for current changeset

    """

    pass

class ChangedFileNodesGenerator(NodeGeneratorBase):

    """

    Class holding Changed files for current changeset

    """

    pass

class RemovedFileNodesGenerator(NodeGeneratorBase):

    """

    Class holding removed files for current changeset

    """

    def __iter__(self):

        for p in self.current_paths:

            yield RemovedFileNode(path=p)

    def __getslice__(self, i, j):

        for p in self.current_paths[i:j]:

            yield RemovedFileNode(path=p)

@functools.total_ordering

class Node(object):

    """

    Simplest class representing file or directory on repository.  SCM backends

    should use ``FileNode`` and ``DirNode`` subclasses rather than ``Node``

    directly.

    Node's ``path`` cannot start with slash as we operate on *relative* paths

    only. Moreover, every single node is identified by the ``path`` attribute,

    so it cannot end with slash, too. Otherwise, path could lead to mistakes.

    """

    def __init__(self, path, kind):

        if path.startswith('/'):

            raise NodeError("Cannot initialize Node objects with slash at "

                            "the beginning as only relative paths are supported")

        self.path = safe_str(path.rstrip('/'))  # we store paths as str

        if path == '' and kind != NodeKind.DIR:

            raise NodeError("Only DirNode and its subclasses may be "

                            "initialized with empty path")

        self.kind = kind

        #self.dirs, self.files = [], []

        if self.is_root() and not self.is_dir():

            raise NodeError("Root node cannot be FILE kind")

    @LazyProperty

    def parent(self):

        parent_path = self.get_parent_path()

        if parent_path:

            if self.changeset:

                return self.changeset.get_node(parent_path)

            return DirNode(parent_path)

        return None

    @LazyProperty

    def name(self):

        """

        Returns name of the node so if its path

        then only last part is returned.

        """

        return safe_unicode(self.path.rstrip('/').split('/')[-1])

    def _get_kind(self):

        return self._kind

    def _set_kind(self, kind):

        if hasattr(self, '_kind'):

            raise NodeError("Cannot change node's kind")

        else:

            self._kind = kind

            # Post setter check (path's trailing slash)

            if self.path.endswith('/'):

                raise NodeError("Node's path cannot end with slash")

    kind = property(_get_kind, _set_kind)

    def __eq__(self, other):

        if self._kind != other._kind:

            return False

        if self.path != other.path:

            return False

        if self.is_file():

            return self.content == other.content

        else:

            # For DirNode's check without entering each dir

            self_nodes_paths = list(sorted(n.path for n in self.nodes))

            other_nodes_paths = list(sorted(n.path for n in self.nodes))

            return self_nodes_paths == other_nodes_paths

    def __lt__(self, other):

        if self._kind < other._kind:

            return True

        if self._kind > other._kind:

            return False

        if self.path < other.path:

            return True

        if self.path > other.path:

            return False

        if self.is_file():

            return self.content < other.content

        else:

            # For DirNode's check without entering each dir

            self_nodes_paths = list(sorted(n.path for n in self.nodes))

            other_nodes_paths = list(sorted(n.path for n in self.nodes))

            return self_nodes_paths < other_nodes_paths

    def __repr__(self):

        return '<%s %r>' % (self.__class__.__name__, self.path)

    def __str__(self):

        return self.__repr__()

    def __unicode__(self):

        return self.name

    def get_parent_path(self):

        """

        Returns node's parent path or empty string if node is root.

        """

        if self.is_root():

            return ''

        return posixpath.dirname(self.path.rstrip('/')) + '/'

    def is_file(self):

        """

        Returns ``True`` if node's kind is ``NodeKind.FILE``, ``False``

        otherwise.

        """

        return self.kind == NodeKind.FILE

    def is_dir(self):

        """

        Returns ``True`` if node's kind is ``NodeKind.DIR``, ``False``

        otherwise.

        """

        return self.kind == NodeKind.DIR

    def is_root(self):

        """

        Returns ``True`` if node is a root node and ``False`` otherwise.

        """

        return self.kind == NodeKind.DIR and self.path == ''

    def is_submodule(self):

        """

        Returns ``True`` if node's kind is ``NodeKind.SUBMODULE``, ``False``

        otherwise.

        """

        return self.kind == NodeKind.SUBMODULE

    @LazyProperty

    def added(self):

        return self.state is NodeState.ADDED

    @LazyProperty

    def changed(self):

        return self.state is NodeState.CHANGED

    @LazyProperty

    def not_changed(self):

        return self.state is NodeState.NOT_CHANGED

    @LazyProperty

    def removed(self):

        return self.state is NodeState.REMOVED

class FileNode(Node):

    """

    Class representing file nodes.

    :attribute: path: path to the node, relative to repository's root

    :attribute: content: if given arbitrary sets content of the file