Welcome to RhodeCode (RhodiumCode) documentation!

=================================================

browser/management tool with a built in push/pull server and full text search.

It works on http/https and has a built in permission/authentication system with 

RhodeCode is similar in some respects to github or bitbucket_, 

however RhodeCode can be run as standalone hosted application on your own server.  

Starting from RhodeCode version 1.2 a simple API was implemented.

    {

        "api_key":"<api_key>",

        "args":{"<arg_key>":"<arg_val>"}

    }

.. note::

    api_key can be found in your user account page    

    {

        "result": "<result>", 

    }

All responses from API will be `HTTP/1.0 200 OK`, if there's an error while

and result will be null.

API METHODS

----

Pulls given repo from remote location. Can be used to automatically keep 

    method: "pull"

    args: {"repo":<repo_name>}

Changelog

=========

======================

:status: in-progress

news

----

- implemented #47 repository groups

- implemented #89 Can setup google analytics code from settings menu

- implemented #91 added nicer looking archive urls with more download options

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import platform

__version__ = '.'.join((str(each) for each in VERSION[:4]))

__platform__ = platform.system()

__license__ = 'GPLv3'

        from rhodecode.lib.profiler import ProfilingMiddleware

        app = ProfilingMiddleware(app)

    app = SimpleHg(app, config)

    app = SimpleGit(app, config)

        app = Cascade([static_app, app])

        app = make_gzip_middleware(app, global_conf, compress_level=1)

    app.config = config

    return app

"""

from __future__ import with_statement

from routes import Mapper

# prefix for non repository related links needs to be prefixed with `/`

ADMIN_PREFIX = '/_admin'

                 always_scan=config['debug'])

    rmap.minimization = False

    rmap.explicit = False

    def check_repo(environ, match_dict):

        """

        check for valid repository for proper 404 handling

        :param environ:

        :param match_dict:

        """

        repo_name = match_dict.get('repo_name')

    def check_int(environ, match_dict):

        return match_dict.get('id').isdigit()

    # The ErrorController route (handles 404/500 error pages); it should

    # likely stay at the top, ensuring it can always be resolved

    rmap.connect('/error/{action}', controller='error')

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

    # REPOSITORY ROUTES

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

    rmap.connect('changeset_home', '/{repo_name:.*}/changeset/{revision}',

                controller='changeset', revision='tip',

                conditions=dict(function=check_repo))

                 controller='changeset', action='raw_changeset',

                 revision='tip', conditions=dict(function=check_repo))

    rmap.connect('summary_home', '/{repo_name:.*}/summary',

                controller='summary', conditions=dict(function=check_repo))

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from formencode import htmlfill

from pylons import request, session, tmpl_context as c, url

from pylons.controllers.util import abort, redirect

from pylons.i18n.translation import _

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator

from rhodecode.lib.base import BaseController, render

from rhodecode.model.permission import PermissionModel

log = logging.getLogger(__name__)

        c.create_choices = self.create_choices

        if id == 'default':

            defaults = {'_method': 'put',

                        'anonymous': default_user.active}

        """

        self.__load_defaults()

        repo = scm_repo = db_repo.scm_instance

        if c.repo_info is None:

            return redirect(url('repos'))

        c.in_public_journal = self.sa.query(UserFollowing)\

            .filter(UserFollowing.user_id == c.default_user_id)\

            .filter(UserFollowing.follows_repository == c.repo_info).scalar()

        token = get_token()

        if cur_token == token:

            try:

                self.scm_model.toggle_following_repo(repo_id, user_id)

                h.flash(_('Updated repository visibility in public journal'),

                        category='success')

    ApplicationUiSettingsForm

from rhodecode.model.scm import ScmModel

from rhodecode.model.user import UserModel

log = logging.getLogger(__name__)

        """

        # url('admin_settings_my_account')

        all_repos = self.sa.query(Repository)\

                     .filter(Repository.user_id == c.user.user_id)\

                     .order_by(func.lower(Repository.repo_name)).all()

                    category='success')

        except formencode.Invalid, errors:

            all_repos = self.sa.query(Repository)\

                .filter(Repository.user_id == c.user.user_id)\

                .order_by(func.lower(Repository.repo_name))\

# MA  02110-1301, USA.

import inspect

import logging

import types

import urllib

from paste.response import replace_header

from webob.exc import HTTPNotFound, HTTPForbidden, HTTPInternalServerError, \

HTTPBadRequest, HTTPError

from rhodecode.lib.auth import AuthUser

log = logging.getLogger('JSONRPC')

        Parse the request body as JSON, look up the method on the

        controller and if it exists, dispatch to it.

        """

        if 'CONTENT_LENGTH' not in environ:

            log.debug("No Content-Length")

        else:

            length = environ['CONTENT_LENGTH'] or 0

            length = int(environ['CONTENT_LENGTH'])

        if length == 0:

            log.debug("Content-Length is 0")

        raw_body = environ['wsgi.input'].read(length)

        try:

            json_body = json.loads(urllib.unquote_plus(raw_body))

            #catch JSON errors Here

                                 % (e, urllib.unquote_plus(raw_body)))

        #check AUTH based on API KEY

        try:

            self._req_api_key = json_body['api_key']

            self._req_method = json_body['method']

            log.debug('method: %s, params: %s',

                      self._req_method,

                      self._req_params)

            return jsonrpc_error(message='Incorrect JSON query missing %s' % e)

        #check if we can find this session using api_key

        try:

            u = User.get_by_api_key(self._req_api_key)

            auth_u = AuthUser(u.user_id, self._req_api_key)

            return jsonrpc_error(message='Invalid API KEY')

        self._error = None

        try:

            self._func = self._find_method()

        except AttributeError, e:

        # now that we have a method, add self._req_params to

        # self.kargs and dispatch control to WGIController

        # this is little trick to inject logged in user for 

        # perms decorators to work they expect the controller class to have

        self.rhodecode_user = auth_u

        # get our arglist and check if we provided them as args

                continue

        self._rpc_args.update(self._req_params)

        self._rpc_args['action'] = self._req_method

        """

        try:

            raw_response = self._inspect_call(self._func)

            if isinstance(raw_response, HTTPError):

                self._error = str(raw_response)

            self._error = str(e)

            json_exc = JSONRPCError('Internal server error')

            self._error = str(json_exc)

            return func

        else:

            raise AttributeError("No such method: %s" % self._req_method)

from rhodecode.controllers.api import JSONRPCController, JSONRPCError

from rhodecode.lib.auth import HasPermissionAllDecorator

from rhodecode.model.scm import ScmModel

class ApiController(JSONRPCController):

    """

    """

    @HasPermissionAllDecorator('hg.admin')

        """

        Dispatch pull action on given repo

        """

        try:

            ScmModel().pull_changes(repo, self.rhodecode_user.username)

            return 'Pulled from %s' % repo

            raise JSONRPCError('Unable to pull changes from "%s"' % repo)

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib import safe_unicode

log = logging.getLogger(__name__)

import logging

from mercurial import graphmod

from pylons import request, session, tmpl_context as c

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.helpers import RepoPage

log = logging.getLogger(__name__)

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import EmptyChangeset

from vcs.exceptions import RepositoryError, ChangesetError, \

ChangesetDoesNotExistError

                filename = file_obj.filename

                content = file_obj.file

            node_path = os.path.join(location, filename)

            author = self.rhodecode_user.full_contact

                c.form_result = login_form.to_python(dict(request.POST))

                #form checks for username/password, now we're authenticated

                username = c.form_result['username']

                auth_user = AuthUser(user.user_id)

                auth_user.set_authenticated()

                session['rhodecode_user'] = auth_user

    def register(self):

        user_model = UserModel()

        c.auto_active = False

            if perm.permission.permission_name == 'hg.register.auto_activate':

                c.auto_active = True

                break

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

from rhodecode.lib.utils import EmptyChangeset

from rhodecode.lib.celerylib import run_task

from rhodecode.lib.celerylib.tasks import get_commits_stats, \

    LANGUAGES_EXTENSIONS_MAP

from rhodecode.lib.helpers import RepoPage

log = logging.getLogger(__name__)

            c.commit_data = stats.commit_activity

            c.overview_data = stats.commit_activity_combined

                               "desc": LANGUAGES_EXTENSIONS_MAP.get(x)})

            c.trending_languages = json.dumps(OrderedDict(

                                       sorted(lang_stats, reverse=True,

from rhodecode.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from rhodecode.lib.base import BaseRepoController, render

log = logging.getLogger(__name__)

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

def __get_lem():

    from pygments import lexers

    from string import lower

    return hashlib.sha1(username + salt).hexdigest()

    """

    :rtype: unicode

    :returns: unicode object

    """