map = Mapper(directory=config['pylons.paths']['controllers'],

                 always_scan=config['debug'])

    map.minimization = False

    map.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')

        return not cr(repo_name, config['base_path'])

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

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

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

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

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

    # CUSTOM ROUTES HERE

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

    #MAIN PAGE

    map.connect('bugtracker', "http://bitbucket.org/marcinkuzminski/rhodecode/issues", _static=True)

    map.connect('gpl_license', "http://www.gnu.org/licenses/gpl.html", _static=True)

    #ADMIN REPOSITORY REST ROUTES

    with map.submapper(path_prefix='/_admin', controller='admin/repos') as m:

        m.connect("repos", "/repos",

             action="create", conditions=dict(method=["POST"]))

        m.connect("repos", "/repos",

             action="index", conditions=dict(method=["GET"]))

        m.connect("formatted_repos", "/repos.{format}",

             action="index",

            conditions=dict(method=["GET"]))

        m.connect("new_repo", "/repos/new",

             action="new", conditions=dict(method=["GET"]))

        m.connect("formatted_new_repo", "/repos/new.{format}",

             action="new", conditions=dict(method=["GET"]))

        m.connect("/repos/{repo_name:.*}",

             action="update", conditions=dict(method=["PUT"],

                                              function=check_repo))

        m.connect("/repos/{repo_name:.*}",

             action="delete", conditions=dict(method=["DELETE"],

                                              function=check_repo))

        m.connect("edit_repo", "/repos/{repo_name:.*}/edit",

             action="edit", conditions=dict(method=["GET"],

                                            function=check_repo))

                action_logger(self.rhodecode_user, 'admin_created_repo',

                              form_result['repo_name'], '', self.sa)                

        except formencode.Invalid, errors:

            c.new_repo = errors.value['repo_name']

            if request.POST.get('user_created'):

                r = render('admin/repos/repo_add_create_repository.html')

            else:              

                r = render('admin/repos/repo_add.html')

            return htmlfill.render(

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")      

        except Exception:

            log.error(traceback.format_exc())

            msg = _('error occured during creation of repository %s') \

                    % form_result.get('repo_name')

            h.flash(msg, category='error')

        if request.POST.get('user_created'):

        return redirect(url('repos'))

    @HasPermissionAllDecorator('hg.admin')

    def new(self, format='html'):

        """GET /repos/new: Form to create a new item"""

        new_repo = request.GET.get('repo', '')

        c.new_repo = h.repo_name_slug(new_repo)

        return render('admin/repos/repo_add.html')

    @HasPermissionAllDecorator('hg.admin')

    def update(self, repo_name):

        """PUT /repos/repo_name: Update an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="PUT" />

        # Or using helpers:

        #    h.form(url('repo', repo_name=ID),

        #           method='put')

        # url('repo', repo_name=ID)

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoForm(edit=True, old_data={'repo_name':repo_name})()

        try:

            int_size = int_size if int_size <= limit else limit 

            c.size = int_size

            session['changelog_size'] = c.size

            session.save()

        else:

            c.size = int(session.get('changelog_size', default))

        changesets = HgModel().get_repo(c.repo_name)

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

        c.total_cs = len(changesets)

        c.pagination = Page(changesets, page=p, item_count=c.total_cs,

                            items_per_page=c.size)

        self._graph(changesets, c.size, p)

        return render('changelog/changelog.html')

    def _graph(self, repo, size, p):

        revcount = size

        if not repo.revisions:return json.dumps([]), 0

        max_rev = repo.revisions[-1]

        offset = 1 if p == 1 else  ((p - 1) * revcount + 1)

        rev_start = repo.revisions[(-1 * offset)]

        revcount = min(max_rev, revcount)

        rev_end = max(0, rev_start - revcount)

        dag = graph_rev(repo.repo, rev_start, rev_end)

        c.dag = tree = list(colored(dag))

        data = []

        for (id, type, ctx, vtx, edges) in tree:

            if type != CHANGESET:

                continue

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

        c.jsdata = json.dumps(data) 

    @LoginRequired()

    @HasRepoPermissionAnyDecorator('repository.read', 'repository.write',

                                   'repository.admin')       

    def __before__(self):

        super(ChangesetController, self).__before__()

    def index(self, revision):

        hg_model = HgModel()

        cut_off_limit = 1024 * 250

        def wrap_to_table(str):

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

                        <tr class="line">

                        <td class="lineno new"></td>

                        <td class="code"><pre>%s</pre></td>

                        </tr>

                      </table>''' % str

        try:

            c.changeset = hg_model.get_repo(c.repo_name).get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

        else:

            try:

                c.changeset_old = c.changeset.parents[0]

            except IndexError:

                c.changeset_old = None

            c.changes = []

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

            # ADDED FILES

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

            c.sum_added = 0

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '', EmptyChangeset())

                if filenode_old.is_binary or node.is_binary:

                    diff = wrap_to_table(_('binary file'))

                else:

                    c.sum_added += node.size

                    if c.sum_added < cut_off_limit:

                        f_udiff = differ.get_udiff(filenode_old, node)

                        diff = differ.DiffProcessor(f_udiff).as_html()

                    else:

                        diff = wrap_to_table(_('Changeset is to big and was cut'

                                            ' off, see raw changeset instead'))

                cs1 = None

                c.changes.append(('added', node, diff, cs1, cs2))

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

            # CHANGED FILES

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

            c.sum_removed = 0    

            for node in c.changeset.changed:

                try:

                    filenode_old = c.changeset_old.get_node(node.path)

                except ChangesetError:

                    filenode_old = FileNode(node.path, '', EmptyChangeset())

                if filenode_old.is_binary or node.is_binary:

                    diff = wrap_to_table(_('binary file'))

                else:

                    if c.sum_removed < cut_off_limit:

                        f_udiff = differ.get_udiff(filenode_old, node)

                        diff = differ.DiffProcessor(f_udiff).as_html()

                        if diff:

                            c.sum_removed += len(diff)

                    else:

                        diff = wrap_to_table(_('Changeset is to big and was cut'

                                            ' off, see raw changeset instead'))

                c.changes.append(('changed', node, diff, cs1, cs2))

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

            # REMOVED FILES    

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

            for node in c.changeset.removed:

                c.changes.append(('removed', node, None, None, None))            

        return render('changeset/changeset.html')

    def raw_changeset(self, revision):

        hg_model = HgModel()

        method = request.GET.get('diff', 'show')

        try:

            c.changeset = hg_model.get_repo(c.repo_name).get_changeset(revision)

        except RepositoryError:

            log.error(traceback.format_exc())

        else:

            try:

                c.changeset_old = c.changeset.parents[0]

            except IndexError:

                c.changeset_old = None

            c.changes = []

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:    

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                cs1 = None

                c.changes.append(('added', node, diff, cs1, cs2))

            for node in c.changeset.changed:

                filenode_old = c.changeset_old.get_node(node.path)

                if filenode_old.is_binary or node.is_binary:

                    diff = _('binary file')

                else:    

                    f_udiff = differ.get_udiff(filenode_old, node)

                    diff = differ.DiffProcessor(f_udiff).raw_diff()

                c.changes.append(('changed', node, diff, cs1, cs2))      

        response.content_type = 'text/plain'

        if method == 'download':

            response.content_disposition = 'attachment; filename=%s.patch' % revision 

        parent = True if len(c.changeset.parents) > 0 else False

        c.parent_tmpl = 'Parent  %s' % c.changeset.parents[0].raw_id if parent else ''

        c.diffs = ''

        for x in c.changes:

            c.diffs += x[2]

        return render('changeset/raw_changeset.html')

    #secure it or not ?

    def __before__(self):

        super(FeedController, self).__before__()

        #common values for feeds

        self.description = 'Changes on %s repository'

        self.title = "%s feed"

        self.language = 'en-us'

        self.ttl = "5"

        self.feed_nr = 10

    def atom(self, repo_name):

        """Produce an atom-1.0 feed via feedgenerator module"""

        feed = Atom1Feed(title=self.title % repo_name,

                         link=url('summary_home', repo_name=repo_name, qualified=True),

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

        changesets = HgModel().get_repo(repo_name)

        for cs in changesets[:self.feed_nr]:

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                                   description=str(cs.date))

        response.content_type = feed.mime_type

        return feed.writeString('utf-8')

    def rss(self, repo_name):

        """Produce an rss2 feed via feedgenerator module"""

        feed = Rss201rev2Feed(title=self.title % repo_name,

                         link=url('summary_home', repo_name=repo_name, qualified=True),

                         description=self.description % repo_name,

                         language=self.language,

                         ttl=self.ttl)

        changesets = HgModel().get_repo(repo_name)

        for cs in changesets[:self.feed_nr]:

            feed.add_item(title=cs.message,

                          link=url('changeset_home', repo_name=repo_name,

                          description=str(cs.date))

        response.content_type = feed.mime_type

        return feed.writeString('utf-8')

        super(FilesController, self).__before__()

        c.file_size_limit = 250 * 1024 #limit of file size to display

    def index(self, repo_name, revision, f_path):

        hg_model = HgModel()

        c.repo = repo = hg_model.get_repo(c.repo_name)

        revision = request.POST.get('at_rev', None) or revision

        def get_next_rev(cur):

            max_rev = len(c.repo.revisions) - 1

            r = cur + 1

            if r > max_rev:

                r = max_rev

            return r

        def get_prev_rev(cur):

            r = cur - 1

            return r

        c.f_path = f_path

        try:

            cur_rev = repo.get_changeset(revision).revision

            c.url_prev = url('files_home', repo_name=c.repo_name,

                             revision=prev_rev, f_path=f_path) 

            c.url_next = url('files_home', repo_name=c.repo_name,

                             revision=next_rev, f_path=f_path)   

            c.changeset = repo.get_changeset(revision)

            c.rev_nr = c.changeset.revision

            c.files_list = c.changeset.get_node(f_path)

            c.file_history = self._get_history(repo, c.files_list, f_path)

        except (RepositoryError, ChangesetError):

            c.files_list = None

        return render('files/files.html')

    def rawfile(self, repo_name, revision, f_path):

        hg_model = HgModel()

        c.repo = hg_model.get_repo(c.repo_name)

        file_node = c.repo.get_changeset(revision).get_node(f_path)

        response.content_type = file_node.mimetype

        response.content_disposition = 'attachment; filename=%s' \

                                                    % f_path.split('/')[-1] 

        return file_node.content

    def raw(self, repo_name, revision, f_path):

        hg_model = HgModel()

        c.repo = hg_model.get_repo(c.repo_name)

        file_node = c.repo.get_changeset(revision).get_node(f_path)

        response.content_type = 'text/plain'

        return file_node.content

    def annotate(self, repo_name, revision, f_path):

        hg_model = HgModel()

        c.repo = hg_model.get_repo(c.repo_name)

        cs = c.repo.get_changeset(revision)

        c.file = cs.get_node(f_path)

        c.file_msg = cs.get_file_message(f_path)

        c.rev_nr = cs.revision        

        c.f_path = f_path

        return render('files/files_annotate.html')

    def archivefile(self, repo_name, revision, fileformat):

        archive_specs = {

          '.tar.bz2': ('application/x-tar', 'tbz2'),

          '.tar.gz': ('application/x-tar', 'tgz'),

          '.zip': ('application/zip', 'zip'),

        }

        if not archive_specs.has_key(fileformat):

            return 'Unknown archive type %s' % fileformat

        def read_in_chunks(file_object, chunk_size=1024 * 40):

            """Lazy function (generator) to read a file piece by piece.

            Default chunk size: 40k."""

            while True:

                data = file_object.read(chunk_size)

                if not data:

                    break

                yield data        

        archive = tempfile.TemporaryFile()

        diff2 = request.GET.get('diff2')

        c.action = request.GET.get('diff')

        c.no_changes = diff1 == diff2

        c.f_path = f_path

        c.repo = hg_model.get_repo(c.repo_name)

        try:

            if diff1 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_1 = c.repo.get_changeset(diff1)

                node1 = c.changeset_1.get_node(f_path)

            else:

                c.changeset_1 = EmptyChangeset()

                node1 = FileNode('.', '', changeset=c.changeset_1)

            if diff2 not in ['', None, 'None', '0' * 12, '0' * 40]:

                c.changeset_2 = c.repo.get_changeset(diff2)

                node2 = c.changeset_2.get_node(f_path)

            else:

                c.changeset_2 = EmptyChangeset()

                node2 = FileNode('.', '', changeset=c.changeset_2)

        except RepositoryError:

            return redirect(url('files_home',

                                repo_name=c.repo_name, f_path=f_path))

        f_udiff = differ.get_udiff(node1, node2)

        diff = differ.DiffProcessor(f_udiff)

        if c.action == 'download':

            diff_name = '%s_vs_%s.diff' % (diff1, diff2)

            response.content_type = 'text/plain'

            response.content_disposition = 'attachment; filename=%s' \

                                                    % diff_name             

            return diff.raw_diff()

        elif c.action == 'raw':

            c.cur_diff = '<pre class="raw">%s</pre>' % h.escape(diff.raw_diff())

        elif c.action == 'diff':

            if node1.size > c.file_size_limit or node2.size > c.file_size_limit:

                c.cur_diff = _('Diff is to big to display')

            else:

                c.cur_diff = diff.as_html()

        else:

            #default option

            if node1.size > c.file_size_limit or node2.size > c.file_size_limit:

                c.cur_diff = _('Diff is to big to display')

            else:

                c.cur_diff = diff.as_html()

        if not c.cur_diff: c.no_changes = True    

        return render('files/file_diff.html')

    def _get_history(self, repo, node, f_path):

        from vcs.nodes import NodeKind

        if not node.kind is NodeKind.FILE:

            return []

        changesets = node.history

        hist_l = []

        for chs in changesets:

            n_desc = 'r%s:%s' % (chs.revision, chs.short_id)

        return hist_l

# of the License or (at your opinion) any later version of the license.

# 

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

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

# along with this program; if not, write to the Free Software

# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

# MA  02110-1301, USA.

"""

Created on February 18, 2010

hg controller for pylons

@author: marcink

"""

from operator import itemgetter

from pylons import tmpl_context as c, request

from rhodecode.lib.auth import LoginRequired

from rhodecode.lib.base import BaseController, render

from rhodecode.model.hg import HgModel

import logging

log = logging.getLogger(__name__)

    @LoginRequired()

    def __before__(self):

    def index(self):

        sortables = ['name', 'description', 'last_change', 'tip', 'contact']

        current_sort = request.GET.get('sort', 'name')

        current_sort_slug = current_sort.replace('-', '')

        if current_sort_slug not in sortables:

            c.sort_by = 'name'

            current_sort_slug = c.sort_by

        else:

            c.sort_by = current_sort

        c.sort_slug = current_sort_slug

        cached_repo_list = HgModel().get_repos()

        sort_key = current_sort_slug + '_sort'

        if c.sort_by.startswith('-'):

            c.repos_list = sorted(cached_repo_list, key=itemgetter(sort_key), reverse=True)

        else:

            c.repos_list = sorted(cached_repo_list, key=itemgetter(sort_key), reverse=False)

        return render('/index.html')

from formencode import htmlfill

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

from pylons.controllers.util import abort, redirect

from rhodecode.lib.auth import AuthUser, HasPermissionAnyDecorator

from rhodecode.lib.base import BaseController, render

import rhodecode.lib.helpers as h 

from pylons.i18n.translation import _

from rhodecode.model.forms import LoginForm, RegisterForm, PasswordResetForm

from rhodecode.model.user import UserModel

import formencode

import logging

log = logging.getLogger(__name__)

class LoginController(BaseController):

    def __before__(self):

        super(LoginController, self).__before__()

    def index(self):

        #redirect if already logged in

        c.came_from = request.GET.get('came_from', None)

        if c.rhodecode_user.is_authenticated:

        if request.POST:

            #import Login Form validator class

            login_form = LoginForm()

            try:

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

                username = c.form_result['username']

                user = UserModel().get_by_username(username)

                auth_user = AuthUser()

                auth_user.username = user.username

                auth_user.is_authenticated = True

                auth_user.is_admin = user.admin

                auth_user.user_id = user.user_id

                auth_user.name = user.name

                auth_user.lastname = user.lastname

                session['rhodecode_user'] = auth_user

                session.save()

                log.info('user %s is now authenticated', username)

                user.update_lastlogin()

                if c.came_from:

                    return redirect(c.came_from)

                else:

            except formencode.Invalid, errors:

                return htmlfill.render(

                    render('/login.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8")

        return render('/login.html')

    @HasPermissionAnyDecorator('hg.admin', 'hg.register.auto_activate',

                               'hg.register.manual_activate')

    def register(self):

        user_model = UserModel()

        c.auto_active = False

        for perm in user_model.get_by_username('default', cache=False).user_perms:

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

                c.auto_active = True

                break

        if request.POST:

            register_form = RegisterForm()()

        if request.POST:

            password_reset_form = PasswordResetForm()()

            try:

                form_result = password_reset_form.to_python(dict(request.POST))

                user_model.reset_password(form_result)

                h.flash(_('Your new password was sent'),

                            category='success')                 

                return redirect(url('login_home'))

            except formencode.Invalid, errors:

                return htmlfill.render(

                    render('/password_reset.html'),

                    defaults=errors.value,

                    errors=errors.error_dict or {},

                    prefix_error=False,

                    encoding="UTF-8")

        return render('/password_reset.html')

    def logout(self):

        session['rhodecode_user'] = AuthUser()

        session.save()

        log.info('Logging out and setting user as Empty')

import formencode

import logging

import rhodecode.lib.helpers as h

import traceback

log = logging.getLogger(__name__)

class SettingsController(BaseController):

    @LoginRequired()

    @HasRepoPermissionAllDecorator('repository.admin')           

    def __before__(self):

        super(SettingsController, self).__before__()

    def index(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

        defaults = c.repo_info.__dict__

        defaults.update({'user':c.repo_info.user.username})

        c.users_array = repo_model.get_users_js()

        for p in c.repo_info.repo_to_perm:

            defaults.update({'perm_%s' % p.user.username: 

                             p.permission.permission_name})

        return htmlfill.render(

            render('settings/repo_settings.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False

        )  

    def update(self, repo_name):

        repo_model = RepoModel()

        changed_name = repo_name

        _form = RepoSettingsForm(edit=True, old_data={'repo_name':repo_name})()

        try:

            form_result = _form.to_python(dict(request.POST))

            repo_model.update(repo_name, form_result)

            invalidate_cache('cached_repo_list')

            h.flash(_('Repository %s updated successfully' % repo_name),

                    % repo_name, category='error')

        return redirect(url('repo_settings_home', repo_name=changed_name))

    def delete(self, repo_name):    

        """DELETE /repos/repo_name: Delete an existing item"""

        # Forms posted to this method should contain a hidden field:

        #    <input type="hidden" name="_method" value="DELETE" />

        # Or using helpers:

        #    h.form(url('repo_settings_delete', repo_name=ID),

        #           method='delete')

        # url('repo_settings_delete', repo_name=ID)

        repo_model = RepoModel()

        repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was moved or renamed  from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

        try:

            action_logger(self.rhodecode_user, 'user_deleted_repo',

                              repo_name, '', self.sa)            

            repo_model.delete(repo)            

            invalidate_cache('cached_repo_list')

            h.flash(_('deleted repository %s') % repo_name, category='success')

        except Exception:

            h.flash(_('An error occurred during deletion of %s') % repo_name,

                    category='error')

    def fork(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo = repo_model.get(repo_name)

        if not repo:

            h.flash(_('%s repository is not mapped to db perhaps' 

                      ' it was created or renamed from the filesystem'

                      ' please run the application again'

                      ' in order to rescan repositories') % repo_name,

                      category='error')

        return render('settings/repo_fork.html')

    def fork_create(self, repo_name):

        repo_model = RepoModel()

        c.repo_info = repo_model.get(repo_name)

        _form = RepoForkForm()()

        form_result = {}

        try:

            form_result = _form.to_python(dict(request.POST))

            form_result.update({'repo_name':repo_name})

            repo_model.create_fork(form_result, c.rhodecode_user)

            h.flash(_('fork %s repository as %s task added') \

                      % (repo_name, form_result['fork_name']),

                    category='success')

            action_logger(self.rhodecode_user, 'user_forked_repo',

                            repo_name, '', self.sa)                                                 

        except formencode.Invalid, errors:

            c.new_repo = errors.value['fork_name']

            r = render('settings/repo_fork.html')

            return htmlfill.render(

                r,

                defaults=errors.value,

                errors=errors.error_dict or {},

                prefix_error=False,

                encoding="UTF-8")   

        for c in xrange(n):

            h += golden_ratio

            h %= 1

            HSV_tuple = [h, 0.95, 0.95]

            RGB_tuple = colorsys.hsv_to_rgb(*HSV_tuple)

            yield map(lambda x:str(int(x * 256)), RGB_tuple)

    cgenerator = gen_color()