1.3.5 (**2012-05-10**)

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

news

++++

- use ext_json for json module

- unified annotation view with file source view

- notification improvements, better inbox + css

- #419 don't strip passwords for login forms, make rhodecode 

  more compatible with LDAP servers

- Added HTTP_X_FORWARDED_FOR as another method of extracting 

  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

- added support for displaying submodules in file-browser

- #421 added bookmarks in changelog view

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

- fixed #434: Error when accessing files or changesets of a git repository 

  with submodules

- fixed issue with empty APIKEYS for users after registration ref. #438

- fixed issue with getting README files from git repositories

import sys

import os

import datetime

extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest',

              'sphinx.ext.intersphinx', 'sphinx.ext.todo',

              'sphinx.ext.viewcode']

copyright = u'%s, Marcin Kuzminski' % (datetime.datetime.now().year)

VERSION = (1, 3, 5)

is_windows = __platform__ in PLATFORM_WIN

is_unix = __platform__ in PLATFORM_OTHERS

    "Mako==0.7.0",

    "whoosh>=2.4.0,<2.5",

    "dulwich>=0.8.5,<0.9.0",

if is_windows:

    requirements.append("mercurial>=2.2.1,<2.3")

    requirements.append("mercurial>=2.2.1,<2.3")

                 controller='files', action='index', revision='tip',

                 f_path='', annotate=True, conditions=dict(function=check_repo))

        # check the ldap lib

        ldap_active = False

        try:

            import ldap

            ldap_active = True

        except ImportError:

            pass

                        if k == 'ldap_active':

                            v = ldap_active

                        category='success')

                if not ldap_active:

                    #if ldap is missing send an info to user

                    h.flash(_('Unable to activate ldap. The "python-ldap" library '

                              'is missing.'), category='warning')

from webhelpers.paginate import Page

        notif = NotificationModel().get_for_user(self.rhodecode_user.user_id)

        p = int(request.params.get('page', 1))

        c.notifications = Page(notif, page=p, items_per_page=10)

            notif = nm.get_for_user(self.rhodecode_user.user_id)

            c.notifications = Page(notif, page=1, items_per_page=10)

import pkg_resources

import platform

        c.modules = sorted([(p.project_name, p.version)

                            for p in pkg_resources.working_set],

                           key=lambda k: k[0].lower())

        c.py_version = platform.python_version()

        c.platform = platform.platform()

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

            c.dag = graphmod.colored(dag, repo._repo)

    @jsonify

        comm = ChangesetCommentsModel().create(

            text=request.POST.get('text'),

            repo_id=c.rhodecode_db_repo.repo_id,

            user_id=c.rhodecode_user.user_id,

            revision=revision,

            f_path=request.POST.get('f_path'),

            line_no=request.POST.get('line')

        )

        if not request.environ.get('HTTP_X_PARTIAL_XHR'):

            return redirect(h.url('changeset_home', repo_name=repo_name,

                                  revision=revision))

        data = {

           'target_id': h.safeid(h.safe_unicode(request.POST.get('f_path'))),

        }

        if comm:

            c.co = comm

            data.update(comm.get_dict())

            data.update({'rendered_text':

                         render('changeset/changeset_comment_block.html')})

        return data

from rhodecode.model.db import Repository

    def index(self, repo_name, revision, f_path, annotate=False):

        c.annotate = annotate

            safe_str(f_path.split(Repository.url_sep())[-1])

                                           repo_name=repo_name, cs=c.cs,

                                           user=self.rhodecode_user,

                                           author=author, message=message,

                                           content=content, f_path=node_path)

    NotAnonymous, HasRepoPermissionAny

        d = []

        for r in Repository.get_repo_forks(repo_id):

            if not HasRepoPermissionAny(

                'repository.read', 'repository.write', 'repository.admin'

            )(r.repo_name, 'get forks check'):

                continue

            d.append(r)

        c.readme_data, c.readme_file = self.__get_readme_data(

            c.rhodecode_db_repo.repo_name, c.rhodecode_repo

        )

    def __get_readme_data(self, repo_name, repo):

                cs = repo.get_changeset()  # fetches TIP

                log.error(traceback.format_exc())

        key = repo_name + '_README'

    def _get_ip_addr(self, environ):

        proxy_key = 'HTTP_X_REAL_IP'

        proxy_key2 = 'HTTP_X_FORWARDED_FOR'

        def_key = 'REMOTE_ADDR'

        return environ.get(proxy_key2,

                           environ.get(proxy_key,

                                       environ.get(def_key, '0.0.0.0')

                            )

                        )

from rhodecode.lib.hooks import log_create_repository

    fork_repo = RepoModel(DBS).create(form_data, cur_user,

                                      just_db=True, fork=True)

    log_create_repository(fork_repo.get_dict(), created_by=cur_user.username)

from rhodecode.lib.ext_json import json

from rhodecode.lib.vcs.nodes import FileNode, SubModuleNode

from rhodecode.lib.helpers import escape

        submodules = filter(lambda o: isinstance(o, SubModuleNode),

                            [filenode_new, filenode_old])

        if submodules:

            diff = wrap_to_table(escape('Submodule %r' % submodules[0]))

        else:

            diff = wrap_to_table(_('No changes detected'))

    submodules = filter(lambda o: isinstance(o, SubModuleNode),

                        [filenode_new, filenode_old])

    if submodules:

        return ''

import datetime

import functools

import decimal

__all__ = ['json', 'simplejson', 'stdjson']

def _is_aware(value):

    """

    Determines if a given datetime.time is aware.

    The logic is described in Python's docs:

    http://docs.python.org/library/datetime.html#datetime.tzinfo

    """

    return (value.tzinfo is not None

            and value.tzinfo.utcoffset(value) is not None)

def _obj_dump(obj):

    """

    Custom function for dumping objects to JSON, if obj has __json__ attribute

    or method defined it will be used for serialization

    :param obj:

    """

    if isinstance(obj, complex):

        return [obj.real, obj.imag]

    # See "Date Time String Format" in the ECMA-262 specification.

    # some code borrowed from django 1.4

    elif isinstance(obj, datetime.datetime):

        r = obj.isoformat()

        if obj.microsecond:

            r = r[:23] + r[26:]

        if r.endswith('+00:00'):

            r = r[:-6] + 'Z'

        return r

    elif isinstance(obj, datetime.date):

        return obj.isoformat()

    elif isinstance(obj, decimal.Decimal):

        return str(obj)

    elif isinstance(obj, datetime.time):

        if _is_aware(obj):

            raise ValueError("JSON can't represent timezone-aware times.")

        r = obj.isoformat()

        if obj.microsecond:

            r = r[:12]

        return r

    elif isinstance(obj, set):

        return list(obj)

    elif hasattr(obj, '__json__'):

        if callable(obj.__json__):

            return obj.__json__()

        else:

            return obj.__json__

    else:

        raise NotImplementedError

# Import simplejson

try:

    # import simplejson initially

    import simplejson as _sj

    def extended_encode(obj):

        try:

            return _obj_dump(obj)

        except NotImplementedError:

            pass

        raise TypeError("%r is not JSON serializable" % (obj,))

    # we handle decimals our own it makes unified behavior of json vs

    # simplejson

    _sj.dumps = functools.partial(_sj.dumps, default=extended_encode,

                                  use_decimal=False)

    _sj.dump = functools.partial(_sj.dump, default=extended_encode,

                                 use_decimal=False)

    simplejson = _sj

except ImportError:

    # no simplejson set it to None

    _sj = None

# simplejson not found try out regular json module

import json as _json

# extended JSON encoder for json

class ExtendedEncoder(_json.JSONEncoder):

    def default(self, obj):

        try:

            return _obj_dump(obj)

        except NotImplementedError:

            pass

        return _json.JSONEncoder.default(self, obj)

# monkey-patch JSON encoder to use extended version

_json.dumps = functools.partial(_json.dumps, cls=ExtendedEncoder)

_json.dump = functools.partial(_json.dump, cls=ExtendedEncoder)

stdlib = _json

# set all available json modules

simplejson = _sj

stdjson = _json

json = _sj if _sj else _json

        except AttributeError:  # Python < 2.4

        revs = []

        if len(filter(lambda v: v != '', revs_ids)) > 0:

            # get only max revs_top_limit of changeset for performance/ui reasons

            revs = [

                x for x in repo.get_changesets(revs_ids[0],

                                               revs_ids[:revs_top_limit][-1])

            ]

def _get_scm_size(alias, root_path):

    if not alias.startswith('.'):

        alias += '.'

    size_scm, size_root = 0, 0

    for path, dirs, files in os.walk(root_path):