IP for pull/push logs. - moved all to base controller  

- #415: Adding comment to changeset causes reload. 

  Comments are now added via ajax and doesn't reload the page

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

+++++

- fixed dev-version marker for stable when served from source codes

- fixed missing permission checks on show forks page

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

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

news

++++

# If your documentation needs a minimal Sphinx version, state it here.

#needs_sphinx = '1.0'

# 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.

templates_path = ['_templates']

# The suffix of source filenames.

Beaker==1.6.3

WebHelpers==1.3

formencode==1.2.4

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

dulwich>=0.8.5,<0.9.0

webob==1.0.8

markdown==2.1.1

docutils==0.8.1

py-bcrypt

    "Beaker==1.6.3",

    "WebHelpers==1.3",

    "formencode==1.2.4",

    "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",

    "dulwich>=0.8.5,<0.9.0",

    "webob==1.0.8",

    "markdown==2.1.1",

if __py_version__ < (2, 6):

    requirements.append("simplejson")

    requirements.append("pysqlite")

if __platform__ in PLATFORM_WIN:

else:

    requirements.append("py-bcrypt")

def get_version():

    """Returns shorter version (digit parts only) as string."""

    return '.'.join((str(each) for each in VERSION[:3]))

                vtx = [0, 1]

                edges = [[0, 0, 1]]

                data.append(['', vtx, edges])

        elif repo.alias == 'hg':

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

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

                if type != graphmod.CHANGESET:

                    continue

                data.append(['', vtx, edges])

        c.jsdata = json.dumps(data)

import markupsafe

from itertools import tee, imap

from pylons.i18n.translation import _

from rhodecode.lib.vcs.exceptions import VCSError

from rhodecode.lib.utils import EmptyChangeset

def wrap_to_table(str_):

    return '''<table class="code-difftable">

                <tr class="line no-comment">

        size = len(diff or '')

    else:

        diff = wrap_to_table(_('Changeset was to big and was cut off, use '

                               '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

    return size, cs1, cs2, diff, stats

    Returns git style diff between given ``filenode_old`` and ``filenode_new``.

    :param ignore_whitespace: ignore whitespaces in diff

    """

    # make sure we pass in default context

    context = context or 3

    for filenode in (filenode_old, filenode_new):

        if not isinstance(filenode, FileNode):

            raise VCSError("Given object should be FileNode object, not %s"

                % filenode.__class__)

    repo = filenode_new.changeset.repository

    old_raw_id = getattr(filenode_old.changeset, 'raw_id', repo.EMPTY_CHANGESET)

    new_raw_id = getattr(filenode_new.changeset, 'raw_id', repo.EMPTY_CHANGESET)

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

                                 ignore_whitespace, context)

    return vcs_gitdiff

class DiffProcessor(object):

    """

    Give it a unified diff and it returns a list of the files that were

def log_push_action(ui, repo, **kwargs):

    """

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

    :param ui:

    """

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

    username = extras['username']

    repository = extras['repository']

    action = extras['action'] + ':%s'

        try:

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

            return app(environ, start_response)

        except Exception:

            log.error(traceback.format_exc())

        else:

            # try to fallback to stored variable as we don't know if the last

            # operation is pull/push

            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:

            return

        from rhodecode.model.db import Repository

        _repo._repo.ui = baseui

        push_hook = 'pretxnchangegroup.push_logger'

        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={}):

        """

        Injects some extra params into baseui instance

        :param baseui: baseui instance

        :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

from rhodecode.lib.vcs.exceptions import ChangesetError

from rhodecode.lib.vcs.exceptions import NodeDoesNotExistError

from rhodecode.lib.vcs.exceptions import VCSError

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

class GitChangeset(BaseChangeset):

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

        path = self._fix_path(path)

        id = self._get_id_for_path(path)

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

            else:

                obj_path = name

            if obj_path not in self._stat_modes:

    def get_node(self, path):

        if isinstance(path, unicode):

            path = path.encode('utf-8')

        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]

    @LazyProperty

    def affected_files(self):

                if not len(splitted) == 2:

                    raise VCSError("Couldn't parse diff result:\n%s\n\n and "

                        "particularly that line: %s" % (self._diff_name_status,

                        line))

                _path = splitted[1].strip()

                paths.add(_path)

        return sorted(paths)

    @LazyProperty

    def added(self):

        """

        Returns list of added ``FileNode`` objects.

        self._repo = self._get_repo(create, src_url, update_after_clone, bare)

        #temporary set that to now at later we will move it to constructor

        baseui = None

        if baseui is None:

            from mercurial.ui import ui

            baseui = ui()

        # compatibility layer with Mercurial

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

        try:

            self.head = self._repo.head()

        except KeyError:

        if reverse:

            revs = reversed(revs)

        for rev in revs:

            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``.

        :param rev1: Entry point from which diff is shown. Can be

          ``self.EMPTY_CHANGESET`` - in this case, patch showing all

import posixpath

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

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

from rhodecode.lib.vcs.utils.paths import get_dirs_for_path

from ...utils.hgcompat import archival, hex

        path = self._fix_path(path)

        if self._get_kind(path) != NodeKind.FILE:

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

                " %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``.

        """

        fctx = self._get_filectx(path)

        if 'x' in fctx.flags():

        """

        if self._get_kind(path) != NodeKind.DIR:

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

        """

        Returns ``Node`` object from the given ``path``. If there is no node at

        the given ``path``, ``ChangesetError`` would be raised.

    Module holding everything related to vcs nodes.

    :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

class NodeState:

    ADDED = u'added'

    def is_root(self):

        """

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

        """

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

    @LazyProperty

    def added(self):

        return self.state is NodeState.ADDED

    @LazyProperty

    def changed(self):

    def __init__(self, nodes=(), changeset=None):

        super(RootNode, self).__init__(path='', nodes=nodes,

            changeset=changeset)

    def __repr__(self):

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

	background: url("../images/icons/folder_16.png") no-repeat scroll 3px;

	height: 16px;

	padding-left: 20px;

	text-align: left;

}

.box .search {

	clear: both;

	overflow: hidden;

	margin: 0;

	padding: 0 20px 10px;

}

                        <div class="parent">${_('No parents')}</div>

                    %endif

		         <span class="logtags">

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

		             %endfor

		         </span>

	                </div>

				</tr>

          		%endif

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

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

		             <td>

		             </td>

		             <td>

		             %if node.is_file():

		             	${h.format_byte_size(node.size,binary=True)}

		             %endif

		             </td>

            </tbody>

            </table>

            </div>

        </div>

    </div>

    <script>

      var func = function(node){

          return node.parentNode.parentNode.parentNode.parentNode;

      }

      // groups table sorting

%for cnt,cs in enumerate(c.repo_changesets):

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

        <td>

            <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><span class="tooltip" title="${cs.date}">

                      ${h.age(cs.date)}</span>

        </td>

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

		<td>

			<span class="logtags">

				<span class="branchtag">

                    ${cs.branch}

                </span>

			</span>

		</td>

		<td>

			<span class="logtags">

				%for tag in cs.tags:

					<span class="tagtag">${tag}</span>