- #374 LDAP config is discarded when LDAP can't be activated

- limited push/pull operations are now logged for git in the journal

- bumped mercurial to 2.2.X series

fixes

+++++

- #418 cast to unicode fixes in notification objects

- #426 fixed mention extracting regex

- fixed remote-pulling for git remotes remopositories

1.3.4 (**2012-03-28**)

----------------------

# Add any Sphinx extension module names here, as strings. They can be extensions

# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.

              'sphinx.ext.viewcode']

# Add any paths that contain templates here, relative to this directory.

SQLAlchemy==0.7.6

Mako==0.7.0

pygments>=1.4

celery>=2.2.5,<2.3

babel

python-dateutil>=1.5.0,<2.0.0

markdown==2.1.1

docutils==0.8.1

py-bcrypt

    "SQLAlchemy==0.7.6",

    "Mako==0.7.0",

    "pygments>=1.4",

    "celery>=2.2.5,<2.3",

    "babel",

    "python-dateutil>=1.5.0,<2.0.0",

    requirements.append("pysqlite")

if __platform__ in PLATFORM_WIN:

else:

    requirements.append("py-bcrypt")

def get_version():

        elif repo.alias == 'hg':

            dag = graphmod.dagwalker(repo._repo, revs)

            for (id, type, ctx, vtx, edges) in c.dag:

                if type != graphmod.CHANGESET:

                    continue

from pylons.i18n.translation import _

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.utils import EmptyChangeset

                               'diff menu to display this diff'))

        stats = (0, 0)

        size = 0

    if not diff:

    cs1 = filenode_old.changeset.raw_id

    cs2 = filenode_new.changeset.raw_id

    """

    # make sure we pass in default context

    context = context or 3

    for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

    vcs_gitdiff = repo.get_diff(old_raw_id, new_raw_id, filenode_new.path,

                                 ignore_whitespace, context)

    return vcs_gitdiff

    Maps user last push action to new changeset id, from mercurial

    :param ui:

    """

    extras = dict(repo.ui.configitems('rhodecode_extras'))

            # invalidate cache on push

            if action == 'push':

                self._invalidate_cache(repo_name)

            log.info('%s action on GIT repo "%s"' % (action, repo_name))

            app = self.__make_app(repo_name, repo_path)

            op = getattr(self, '_git_stored_op', 'pull')

        return op

        from rhodecode.lib.hooks import log_pull_action, log_push_action

        service = environ['QUERY_STRING'].split('=')

        if len(service) < 2:

        pull_hook = 'preoutgoing.pull_logger'

        _hooks = dict(baseui.configitems('hooks')) or {}

        if action == 'push' and _hooks.get(push_hook):

        elif action == 'pull' and _hooks.get(pull_hook):

    def __inject_extras(self, repo_path, baseui, extras={}):

        """

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

        """

        raise NotImplementedError

from rhodecode.lib.vcs.exceptions import ChangesetDoesNotExistError

from rhodecode.lib.vcs.exceptions import ImproperArchiveTypeError

from rhodecode.lib.vcs.backends.base import BaseChangeset

from rhodecode.lib.vcs.utils import safe_unicode

from rhodecode.lib.vcs.utils import date_fromtimestamp

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

        tree = self.repository._repo[id]

        dirnodes = []

        filenodes = []

        for name, stat, id in tree.iteritems():

            obj = self.repository._repo.get_object(id)

            if path != '':

                obj_path = '/'.join((path, name))

        path = self._fix_path(path)

        if not path in self.nodes:

            try:

            except ChangesetError:

                raise NodeDoesNotExistError("Cannot find one of parents' "

                    "directories for a given path: %s" % path)

                else:

            # cache node

            self.nodes[path] = node

        return self.nodes[path]

                        line))

                _path = splitted[1].strip()

                paths.add(_path)

        return sorted(paths)

    @LazyProperty

        if baseui is None:

            from mercurial.ui import ui

            baseui = ui()

        # compatibility layer with Mercurial

        setattr(self._repo, 'ui', baseui)

            yield self.get_changeset(rev)

    def get_diff(self, rev1, rev2, path=None, ignore_whitespace=False,

        """

        Returns (git like) *diff*, as plain text. Shows changes introduced by

        ``rev2`` since ``rev1``.

from rhodecode.lib.vcs.conf import settings

from rhodecode.lib.vcs.exceptions import  ChangesetDoesNotExistError, \

    ChangesetError, ImproperArchiveTypeError, NodeDoesNotExistError, VCSError

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

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

                " %r" % (self.revision, path))

        return self._ctx.filectx(path)

    def get_file_mode(self, path):

        """

        Returns stat mode of the file at the given ``path``.

            raise ChangesetError("Directory does not exist for revision %r at "

                " %r" % (self.revision, path))

        path = self._fix_path(path)

        filenodes = [FileNode(f, changeset=self) for f in self._file_paths

            if os.path.dirname(f) == path]

        dirs = path == '' and '' or [d for d in self._dir_paths

            if d and posixpath.dirname(d) == path]

        dirnodes = [DirNode(d, changeset=self) for d in dirs

            if os.path.dirname(d) == path]

        nodes = dirnodes + filenodes

        # cache nodes

        for node in nodes:

            self.nodes[node.path] = node

        nodes.sort()

        return nodes

    def get_node(self, path):

    :created_on: Apr 8, 2010

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

"""

import stat

import posixpath

import mimetypes

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

from rhodecode.lib.vcs.exceptions import NodeError

from rhodecode.lib.vcs.exceptions import RemovedFileNodeError

class NodeKind:

    DIR = 1

    FILE = 2

        """

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

    @LazyProperty

    def added(self):

        return self.state is NodeState.ADDED

    def __repr__(self):

        return '<%s>' % self.__class__.__name__

	text-align: left;

}

.box .search {

	clear: both;

	overflow: hidden;

                 %if len(c.changeset.parents)>1:

                 <span class="merge">${_('merge')}</span>

                 %endif

		             %for tag in c.changeset.tags:

		                 <span class="tagtag"  title="${'%s %s' % (_('tag'),tag)}">

		                 ${h.link_to(tag,h.url('files_home',repo_name=c.repo_name,revision=c.changeset.raw_id))}</span>

		    %for cnt,node in enumerate(c.file):

				<tr class="parity${cnt%2}">

		             <td>

		             </td>

		             <td>

		             %if node.is_file():

        </div>

    </div>

    <script>

      var func = function(node){

          return node.parentNode.parentNode.parentNode.parentNode;

      }

            <div><pre><a href="${h.url('files_home',repo_name=c.repo_name,revision=cs.raw_id)}">r${cs.revision}:${h.short_id(cs.raw_id)}</a></pre></div>

        </td>

        <td>

            h.url('changeset_home',repo_name=c.repo_name,revision=cs.raw_id),

            title=cs.message)}

        </td>

		<td title="${cs.author}">${h.person(cs.author)}</td>

		<td>

			<span class="logtags">

				<span class="branchtag">

                    ${cs.branch}

                </span>

			</span>

		</td>

		<td>