"""

        return self.get_node('')

    def next(self, branch=None):

        """

        Returns next changeset from current, if branch is gives it will return

        next changeset belonging to this branch

        :param branch: show changesets within the given named branch

        """

        raise NotImplementedError

    def prev(self, branch=None):

        """

        Returns previous changeset from current, if branch is gives it will

        return previous changeset belonging to this branch

        :param branch: show changesets within the given named branch

        """

        raise NotImplementedError

    @LazyProperty

    def added(self):

        """

        Returns list of added ``FileNode`` objects.

        """

        raise NotImplementedError

    @LazyProperty

    def changed(self):

        """

        Returns list of modified ``FileNode`` objects.

        """

        raise NotImplementedError

    @LazyProperty

    def removed(self):

        """

        Returns list of removed ``FileNode`` objects.

        """

        raise NotImplementedError

    @LazyProperty

    def size(self):

        """

        Returns total number of bytes from contents of all filenodes.

        """

        return sum((node.size for node in self.get_filenodes_generator()))

    def walk(self, topurl=''):

        """

        Similar to os.walk method. Insted of filesystem it walks through

        changeset starting at given ``topurl``.  Returns generator of tuples

        (topnode, dirnodes, filenodes).

        """

        topnode = self.get_node(topurl)

        yield (topnode, topnode.dirs, topnode.files)

        for dirnode in topnode.dirs:

            for tup in self.walk(dirnode.path):

                yield tup

    def get_filenodes_generator(self):

        """

        Returns generator that yields *all* file nodes.

        """

        for topnode, dirs, files in self.walk():

            for node in files:

                yield node

    def as_dict(self):

        """

        Returns dictionary with changeset's attributes and their values.

        """

        data = get_dict_for_attrs(self, ['id', 'raw_id', 'short_id',

            'revision', 'date', 'message'])

        data['author'] = {'name': self.author_name, 'email': self.author_email}

        data['added'] = [node.path for node in self.added]

        data['changed'] = [node.path for node in self.changed]

        data['removed'] = [node.path for node in self.removed]

        return data

class BaseWorkdir(object):

    """

    Working directory representation of single repository.

    :attribute: repository: repository object of working directory

    """

    def __init__(self, repository):

        self.repository = repository

    def get_branch(self):

        """

        Returns name of current branch.

        """

        raise NotImplementedError

    def get_changeset(self):

        """

        Returns current changeset.

        """

        raise NotImplementedError

    def get_added(self):

        """

        Returns list of ``FileNode`` objects marked as *new* in working

        directory.

        """

        raise NotImplementedError

    def get_changed(self):

        """

        Returns list of ``FileNode`` objects *changed* in working directory.

        """

        raise NotImplementedError

    def get_removed(self):

        """

        Returns list of ``RemovedFileNode`` objects marked as *removed* in

        working directory.

        """

        raise NotImplementedError

    def get_untracked(self):

        """

        Returns list of ``FileNode`` objects which are present within working

        directory however are not tracked by repository.

        """

        raise NotImplementedError

    def get_status(self):

        """

        Returns dict with ``added``, ``changed``, ``removed`` and ``untracked``

        lists.

        """

        raise NotImplementedError

    def commit(self, message, **kwargs):

        """

        Commits local (from working directory) changes and returns newly

        created

        ``Changeset``. Updates repository's ``revisions`` list.

        :raises ``CommitError``: if any error occurs while committing

        """

        raise NotImplementedError

    def update(self, revision=None):

        """

        Fetches content of the given revision and populates it within working

        directory.

        """

        raise NotImplementedError

    def checkout_branch(self, branch=None):

        """

        Checks out ``branch`` or the backend's default branch.

        Raises ``BranchDoesNotExistError`` if the branch does not exist.

        """

        raise NotImplementedError

class BaseInMemoryChangeset(object):

    """

    Represents differences between repository's state (most recent head) and

    changes made *in place*.

    **Attributes**

        ``repository``

            repository object for this in-memory-changeset

        ``added``

            list of ``FileNode`` objects marked as *added*

        ``changed``

            list of ``FileNode`` objects marked as *changed*

        ``removed``

            list of ``FileNode`` or ``RemovedFileNode`` objects marked to be

            *removed*

        ``parents``

            list of ``Changeset`` representing parents of in-memory changeset.

            Should always be 2-element sequence.

    """

    def __init__(self, repository):

        self.repository = repository

        self.added = []

        self.changed = []

        self.removed = []

        self.parents = []

    def add(self, *filenodes):

        """

        Marks given ``FileNode`` objects as *to be committed*.

        :raises ``NodeAlreadyExistsError``: if node with same path exists at

          latest changeset

        :raises ``NodeAlreadyAddedError``: if node with same path is already

          marked as *added*

        """

        # Check if not already marked as *added* first

        for node in filenodes:

            if node.path in (n.path for n in self.added):

                raise NodeAlreadyAddedError("Such FileNode %s is already "

                    "marked for addition" % node.path)

        for node in filenodes:

            self.added.append(node)

    def change(self, *filenodes):

        """

        Marks given ``FileNode`` objects to be *changed* in next commit.

        :raises ``EmptyRepositoryError``: if there are no changesets yet

        :raises ``NodeAlreadyExistsError``: if node with same path is already

          marked to be *changed*

        :raises ``NodeAlreadyRemovedError``: if node with same path is already

          marked to be *removed*

        :raises ``NodeDoesNotExistError``: if node doesn't exist in latest

          changeset

        :raises ``NodeNotChangedError``: if node hasn't really be changed

        """

        for node in filenodes:

            if node.path in (n.path for n in self.removed):

                raise NodeAlreadyRemovedError("Node at %s is already marked "

                    "as removed" % node.path)

        try:

            self.repository.get_changeset()

        except EmptyRepositoryError:

            raise EmptyRepositoryError("Nothing to change - try to *add* new "

                "nodes rather than changing them")

        for node in filenodes:

            if node.path in (n.path for n in self.changed):

                raise NodeAlreadyChangedError("Node at '%s' is already "

                    "marked as changed" % node.path)

            self.changed.append(node)

    def remove(self, *filenodes):

        """

        Marks given ``FileNode`` (or ``RemovedFileNode``) objects to be

        *removed* in next commit.

        :raises ``NodeAlreadyRemovedError``: if node has been already marked to

          be *removed*

        :raises ``NodeAlreadyChangedError``: if node has been already marked to

          be *changed*

        """

        for node in filenodes:

            if node.path in (n.path for n in self.removed):

                raise NodeAlreadyRemovedError("Node is already marked to "

                    "for removal at %s" % node.path)

            if node.path in (n.path for n in self.changed):

                raise NodeAlreadyChangedError("Node is already marked to "

                    "be changed at %s" % node.path)

            # We only mark node as *removed* - real removal is done by

            # commit method

            self.removed.append(node)

    def reset(self):

        """

        Resets this instance to initial state (cleans ``added``, ``changed``

        and ``removed`` lists).

        """

        self.added = []

        self.changed = []

        self.removed = []

        self.parents = []

    def get_ipaths(self):

        """

        Returns generator of paths from nodes marked as added, changed or

        removed.

        """

        for node in chain(self.added, self.changed, self.removed):

            yield node.path

    def get_paths(self):

        """

        Returns list of paths from nodes marked as added, changed or removed.

        """

        return list(self.get_ipaths())

    def check_integrity(self, parents=None):

        """

        Checks in-memory changeset's integrity. Also, sets parents if not

        already set.

        :raises CommitError: if any error occurs (i.e.

          ``NodeDoesNotExistError``).

        """

        if not self.parents:

            parents = parents or []

            if len(parents) == 0:

                try:

                    parents = [self.repository.get_changeset(), None]

                except EmptyRepositoryError:

                    parents = [None, None]

            elif len(parents) == 1:

                parents += [None]

            self.parents = parents

        # Local parents, only if not None

        parents = [p for p in self.parents if p]

        # Check nodes marked as added

        for p in parents:

            for node in self.added:

                try:

                    p.get_node(node.path)

                except NodeDoesNotExistError:

                    pass

                else:

                    raise NodeAlreadyExistsError("Node at %s already exists "

                        "at %s" % (node.path, p))

        # Check nodes marked as changed

        missing = set(self.changed)

        not_changed = set(self.changed)

        if self.changed and not parents:

            raise NodeDoesNotExistError(str(self.changed[0].path))

        for p in parents:

            for node in self.changed:

                try:

                    old = p.get_node(node.path)

                    missing.remove(node)

                    if old.content != node.content:

                        not_changed.remove(node)

                except NodeDoesNotExistError:

                    pass

        if self.changed and missing:

            raise NodeDoesNotExistError("Node at %s is missing "

                "(parents: %s)" % (node.path, parents))

        if self.changed and not_changed:

            raise NodeNotChangedError("Node at %s wasn't actually changed "

                "since parents' changesets: %s" % (not_changed.pop().path,

                    parents)

            )

        # Check nodes marked as removed

        if self.removed and not parents:

            raise NodeDoesNotExistError("Cannot remove node at %s as there "

                "were no parents specified" % self.removed[0].path)

        really_removed = set()

        for p in parents:

            for node in self.removed:

                try:

                    p.get_node(node.path)

                    really_removed.add(node)

                except ChangesetError:

                    pass

        not_removed = set(self.removed) - really_removed

        if not_removed:

            raise NodeDoesNotExistError("Cannot remove node at %s from "

                "following parents: %s" % (not_removed[0], parents))

    def commit(self, message, author, parents=None, branch=None, date=None,

            **kwargs):

        """

        Performs in-memory commit (doesn't check workdir in any way) and

        returns newly created ``Changeset``. Updates repository's

        ``revisions``.

        .. note::

            While overriding this method each backend's should call

            ``self.check_integrity(parents)`` in the first place.

        :param message: message of the commit

        :param author: full username, i.e. "Joe Doe <joe.doe@example.com>"

        :param parents: single parent or sequence of parents from which commit

          would be derieved

        :param date: ``datetime.datetime`` instance. Defaults to

          ``datetime.datetime.now()``.

        :param branch: branch name, as string. If none given, default backend's

          branch would be used.

        :raises ``CommitError``: if any error occurs while committing

        """

        raise NotImplementedError

# -*- coding: utf-8 -*-

"""

    vcs.nodes

    ~~~~~~~~~

    Module holding everything related to vcs nodes.

    :created_on: Apr 8, 2010

    :copyright: (c) 2010-2011 by Marcin Kuzminski, Lukasz Balcerzak.

"""

import os

import stat

import posixpath

import mimetypes

from pygments import lexers

from rhodecode.lib.vcs.utils.lazy import LazyProperty

from rhodecode.lib.vcs.utils import safe_unicode, safe_str

from rhodecode.lib.vcs.exceptions import NodeError

from rhodecode.lib.vcs.exceptions import RemovedFileNodeError

class NodeKind:

    SUBMODULE = -1

    DIR = 1

    FILE = 2

class NodeState:

    ADDED = u'added'

    CHANGED = u'changed'

    NOT_CHANGED = u'not changed'

    REMOVED = u'removed'

class NodeGeneratorBase(object):

    """

    Base class for removed added and changed filenodes, it's a lazy generator

    class that will create filenodes only on iteration or call

    The len method doesn't need to create filenodes at all

    """

    def __init__(self, current_paths, cs):

        self.cs = cs

        self.current_paths = current_paths

    def __call__(self):

        return [n for n in self]

    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)

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 = path.rstrip('/')

        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 unicode_path(self):

        return safe_unicode(self.path)

    @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 __cmp__(self, other):

        """

        Comparator using name of the node, needed for quick list sorting.

        """

        kind_cmp = cmp(self.kind, other.kind)

        if kind_cmp:

            return kind_cmp

        return cmp(self.name, other.name)

    def __eq__(self, other):

        for attr in ['name', 'path', 'kind']:

            if getattr(self, attr) != getattr(other, attr):

                return False

        if self.is_file():

            if self.content != other.content:

                return False

        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))

            if self_nodes_paths != other_nodes_paths:

                return False

        return True

    def __nq__(self, other):

        return not self.__eq__(other)

    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 repostiory's root

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

    :attribute: changeset: if given, first time content is accessed, callback

    :attribute: mode: octal stat mode for a node. Default is 0100644.

    """

    def __init__(self, path, content=None, changeset=None, mode=None):

        """

        Only one of ``content`` and ``changeset`` may be given. Passing both

        would raise ``NodeError`` exception.

        :param path: relative path to the node

        :param content: content may be passed to constructor

        :param changeset: if given, will use it to lazily fetch content

        :param mode: octal representation of ST_MODE (i.e. 0100644)

        """

        if content and changeset:

            raise NodeError("Cannot use both content and changeset")

        super(FileNode, self).__init__(path, kind=NodeKind.FILE)

        self.changeset = changeset

        self._content = content

        self._mode = mode or 0100644

    @LazyProperty

    def mode(self):

        """

        Returns lazily mode of the FileNode. If ``changeset`` is not set, would

        use value given at initialization or 0100644 (default).

        """

        if self.changeset:

            mode = self.changeset.get_file_mode(self.path)

        else:

            mode = self._mode

        return mode

    @property

    def content(self):

        """

        Returns lazily content of the FileNode. If possible, would try to

        decode content from UTF-8.

        """

        if self.changeset:

            content = self.changeset.get_file_content(self.path)

        else:

            content = self._content

        if bool(content and '\0' in content):

            return content

        return safe_unicode(content)

    @LazyProperty

    def size(self):

        if self.changeset:

            return self.changeset.get_file_size(self.path)

        raise NodeError("Cannot retrieve size of the file without related "

            "changeset attribute")

    @LazyProperty

    def message(self):

        if self.changeset:

            return self.last_changeset.message

        raise NodeError("Cannot retrieve message of the file without related "

            "changeset attribute")

    @LazyProperty

    def last_changeset(self):

        if self.changeset:

            return self.changeset.get_file_changeset(self.path)

        raise NodeError("Cannot retrieve last changeset of the file without "

            "related changeset attribute")

    def get_mimetype(self):

        """

        Mimetype is calculated based on the file's content. If ``_mimetype``

        attribute is available, it will be returned (backends which store

        mimetypes or can easily recognize them, should set this private

        attribute to indicate that type should *NOT* be calculated).

        """

        if hasattr(self, '_mimetype'):

            if (isinstance(self._mimetype, (tuple, list,)) and

                len(self._mimetype) == 2):

                return self._mimetype

            else:

                raise NodeError('given _mimetype attribute must be an 2 '

                               'element list or tuple')

        mtype, encoding = mimetypes.guess_type(self.name)

        if mtype is None:

            if self.is_binary:

                mtype = 'application/octet-stream'

                encoding = None

            else:

                mtype = 'text/plain'

                encoding = None

        return mtype, encoding

    @LazyProperty

    def mimetype(self):

        """

        Wrapper around full mimetype info. It returns only type of fetched

        mimetype without the encoding part. use get_mimetype function to fetch

        full set of (type,encoding)

        """

        return self.get_mimetype()[0]

    @LazyProperty

    def mimetype_main(self):

        return self.mimetype.split('/')[0]

    @LazyProperty

    def lexer(self):

        """

        Returns pygment's lexer class. Would try to guess lexer taking file's

        content, name and mimetype.

        """

        try:

            lexer = lexers.guess_lexer_for_filename(self.name, self.content)

        except lexers.ClassNotFound:

            lexer = lexers.TextLexer()

        # returns first alias

        return lexer

    @LazyProperty

    def lexer_alias(self):

        """

        Returns first alias of the lexer guessed for this file.

        """

        return self.lexer.aliases[0]

    @LazyProperty

    def history(self):

        """

        Returns a list of changeset for this file in which the file was changed

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_history(self.path)

    @LazyProperty

    def annotate(self):

        """

        Returns a list of three element tuples with lineno,changeset and line

        """

        if self.changeset is None:

            raise NodeError('Unable to get changeset for this FileNode')

        return self.changeset.get_file_annotate(self.path)

    @LazyProperty

    def state(self):

        if not self.changeset:

            raise NodeError("Cannot check state of the node if it's not "

                "linked with changeset")

        elif self.path in (node.path for node in self.changeset.added):

            return NodeState.ADDED

        elif self.path in (node.path for node in self.changeset.changed):

            return NodeState.CHANGED

        else:

            return NodeState.NOT_CHANGED

    @property

    def is_binary(self):

        """