from tg import tmpl_context as c

from tg.i18n import ugettext as _

import kallithea

from kallithea.lib import feeds

from kallithea.lib import helpers as h

from kallithea.lib.auth import HasRepoPermissionLevelDecorator, LoginRequired

from kallithea.lib.base import BaseRepoController

from kallithea.lib.diffs import DiffProcessor

from kallithea.lib.utils2 import asbool, safe_int, safe_str

                            % st)

        if diff_processor.limited_diff:

            changes = changes + ['\n ' +

                                 _('Changeset was too big and was cut off...')]

        # rev link

                   revision=cs.raw_id)

        desc_msg.append('changeset: <a href="%s">%s</a>' % (_url, cs.raw_id[:8]))

        desc_msg.append('<pre>')

        desc_msg.append(h.urlify_text(cs.message))

        desc_msg.append('\n')

        """Produce a simple feed"""

        @cache_region('long_term_file', '_get_feed_from_cache')

        def _get_feed_from_cache(*_cache_keys):  # parameters are not really used - only as caching key

            header = dict(

                title=_('%s %s feed') % (c.site_name, repo_name),

                description=_('Changes on %s repository') % repo_name,

            )

            rss_items_per_page = safe_int(kallithea.CONFIG.get('rss_items_per_page', 20))

            entries=[]

            for cs in reversed(list(c.db_repo_scm_instance[-rss_items_per_page:])):

                entries.append(dict(

                    title=self._get_title(cs),

                    author_email=cs.author_email,

                    author_name=cs.author_name,

                    description=''.join(self.__get_desc(cs)),

                    pubdate=cs.date,

                ))

            return feeder.render(header, entries)

from tg import tmpl_context as c

from tg.i18n import ugettext as _

from webob.exc import HTTPBadRequest

import kallithea.lib.helpers as h

from kallithea.controllers.admin.admin import _journal_filter

from kallithea.lib.auth import LoginRequired

from kallithea.lib.base import BaseController, render

from kallithea.lib.page import Page

from kallithea.lib.utils2 import AttributeDict, safe_int

from kallithea.model import db, meta

from kallithea.model.repo import RepoModel

                                      'full_contact': ''})

            action, action_extra, ico = h.action_parser(entry, feed=True)

            title = "%s - %s %s" % (user.short_contact, action(),

                                    entry.repository.repo_name)

            _url = None

            if entry.repository is not None:

                           repo_name=entry.repository.repo_name)

            entries.append(dict(

                title=title,

                pubdate=entry.action_date,

                author_email=user.email,

                author_name=user.full_name_or_username,

                description=action_extra(),

            ))

        return feeder.render(header, entries)

    def _atom_feed(self, repos, public=True):

        if public:

            desc = '%s %s %s' % (c.site_name, _('Public Journal'),

                                  'atom feed')

        else:

            desc = '%s %s %s' % (c.site_name, _('Journal'), 'atom feed')

        return self._feed(repos, feeds.AtomFeed, link, desc)

    def _rss_feed(self, repos, public=True):

        if public:

            desc = '%s %s %s' % (c.site_name, _('Public Journal'),

                                  'rss feed')

        else:

            desc = '%s %s %s' % (c.site_name, _('Journal'), 'rss feed')

        return self._feed(repos, feeds.RssFeed, link, desc)

    @LoginRequired()

    def index(self):

from kallithea.lib.vcs.backends.base import BaseChangeset, EmptyChangeset

from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError

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

# SCM FILTERS available via h.

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

from kallithea.lib.vcs.utils import author_email, author_name

from kallithea.model import db

from kallithea.model.changeset_status import ChangesetStatusModel

# mute pyflakes "imported but unused"

assert Option

assert HasPermissionAny

assert HasRepoGroupPermissionLevel

assert HasRepoPermissionLevel

assert age

assert time_to_datetime

assert EmptyChangeset

log = logging.getLogger(__name__)

def html_escape(s):

    """Return string with all html escaped.

    This is also safe for javascript in html but not necessarily correct.

    """

    return (s

        .replace('&', '&')

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

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

"""

kallithea.lib.webutils

~~~~~~~~~~~~~~~~~~~~

thread-local "global" variables. It should have few dependencies so it can be

imported anywhere - just like the global variables can be used everywhere.

"""

from tg import request

class UrlGenerator(object):

    """Emulate pylons.url in providing a wrapper around routes.url

    This code was added during migration from Pylons to Turbogears2. Pylons

    already provided a wrapper like this, but Turbogears2 does not.

    def current(self, *args, **kwargs):

        return request.environ['routes.url'].current(*args, **kwargs)

url = UrlGenerator()

import logging

from collections import defaultdict

from tg.i18n import ugettext as _

from kallithea.lib import helpers as h

from kallithea.lib.utils import extract_mentioned_users

from kallithea.model import db, meta

from kallithea.model.notification import NotificationModel

log = logging.getLogger(__name__)

        # changeset

        if revision:

            notification_type = NotificationModel.TYPE_CHANGESET_COMMENT

            cs = repo.scm_instance.get_changeset(revision)

            desc = cs.short_id

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-rev-%s-line-%s@%s' % (repo.repo_name, revision, line_no,

                repo_name=repo.repo_name,

                revision=revision,

                anchor='comment-%s' % comment.comment_id)

            subj = h.link_to(

                'Re changeset: %(desc)s %(line)s' %

                          {'desc': desc, 'line': line},

                cs_author = repo.owner

            recipients.append(cs_author)

            email_kwargs = {

                'status_change': status_change,

                'cs_comment_user': author.full_name_and_username,

                'cs_comment_url': comment_url,

                'raw_id': revision,

                'message': cs.message,

                'message_short': h.shorter(cs.message, 50, firstline=True),

                'cs_author': cs_author,

                'cs_author_username': cs_author.username,

                'repo_name': repo.repo_name,

            notification_type = NotificationModel.TYPE_PULL_REQUEST_COMMENT

            desc = comment.pull_request.title

            _org_ref_type, org_ref_name, _org_rev = comment.pull_request.org_ref.split(':')

            _other_ref_type, other_ref_name, _other_rev = comment.pull_request.other_ref.split(':')

            threading = ['%s-pr-%s@%s' % (pull_request.other_repo.repo_name,

                                          pull_request.pull_request_id,

            if line_no: # TODO: url to file _and_ line number

                threading.append('%s-pr-%s-line-%s@%s' % (pull_request.other_repo.repo_name,

                                                          pull_request.pull_request_id, line_no,

            comment_url = pull_request.url(canonical=True,

                anchor='comment-%s' % comment.comment_id)

            subj = h.link_to(

                'Re pull request %(pr_nice_id)s: %(desc)s %(line)s' %

                          {'desc': desc,

                           'pr_nice_id': comment.pull_request.nice_id(),

                'pr_nice_id': pull_request.nice_id(),

                'status_change': status_change,

                'closing_pr': closing_pr,

                'pr_comment_url': comment_url,

                'pr_url': pull_request.url(canonical=True),

                'pr_comment_user': author.full_name_and_username,

                                   repo_name=pull_request.other_repo.repo_name),

                'pr_target_branch': other_ref_name,

                                   repo_name=pull_request.org_repo.repo_name),

                'pr_source_branch': org_ref_name,

                'pr_owner': pull_request.owner,

                'pr_owner_username': pull_request.owner.username,

                'repo_name': pull_request.other_repo.repo_name,

                'comment_username': author.username,

            log.error("Configured clone_uri_tmpl %r has no '{repo}' or '_{repoid}' and cannot toggle to use repo id URLs", clone_uri_tmpl)

        elif with_id:

            clone_uri_tmpl = clone_uri_tmpl.replace('{repo}', '_{repoid}')

        else:

            clone_uri_tmpl = clone_uri_tmpl.replace('_{repoid}', '{repo}')

        return get_clone_url(clone_uri_tmpl=clone_uri_tmpl,

                             prefix_url=prefix_url,

                             repo_name=self.repo_name,

                             repo_id=self.repo_id,

                             username=username)

            created_on=self.created_on.replace(microsecond=0),

            updated_on=self.updated_on.replace(microsecond=0),

        )

    def url(self, **kwargs):

        canonical = kwargs.pop('canonical', None)

        b = self.org_ref_parts[1]

        if b != self.other_ref_parts[1]:

            s = '/_/' + b

        else:

            s = '/_/' + self.title

        kwargs['extra'] = urlreadable(s)

        if canonical:

                                   pull_request_id=self.pull_request_id, **kwargs)

        return webutils.url('pullrequest_show', repo_name=self.other_repo.repo_name,

                     pull_request_id=self.pull_request_id, **kwargs)

class PullRequestReviewer(meta.Base, BaseDbModel):

    def gist_url(self):

        alias_url = kallithea.CONFIG.get('gist_alias_url')

        if alias_url:

            return alias_url.replace('{gistid}', self.gist_access_id)

    def get_api_data(self):

        """

        Common function for generating gist related data for API

        """

        gist = self

from tg import request

from tg.i18n import ugettext as _

from kallithea.lib import auth

from kallithea.lib import helpers as h

from kallithea.lib.hooks import log_create_pullrequest

from kallithea.lib.utils import extract_mentioned_users

from kallithea.lib.utils2 import ascii_bytes

from kallithea.model import db, meta

from kallithea.model.notification import NotificationModel

            meta.Session().add(prr)

        # notification to reviewers

        pr_url = pr.url(canonical=True)

        threading = ['%s-pr-%s@%s' % (pr.other_repo.repo_name,

                                      pr.pull_request_id,

        subject = h.link_to(

            _('%(user)s wants you to review pull request %(pr_nice_id)s: %(pr_title)s') %

                {'user': user.username,

                 'pr_title': pr.title,

                 'pr_nice_id': pr.nice_id()},

            pr_url)

        revision_data = [(x.raw_id, x.message)

                         for x in map(pr.org_repo.get_changeset, pr.revisions)]

        email_kwargs = {

            'pr_title': pr.title,

            'pr_title_short': h.shorter(pr.title, 50),

            'pr_user_created': user.full_name_and_username,

            'pr_url': pr_url,

            'pr_revisions': revision_data,

            'repo_name': pr.other_repo.repo_name,

            'org_repo_name': pr.org_repo.repo_name,

            'pr_nice_id': pr.nice_id(),

                               repo_name=pr.other_repo.repo_name),

            'pr_target_branch': other_ref_name,

                               repo_name=pr.org_repo.repo_name),

            'pr_source_branch': org_ref_name,

            'pr_owner': pr.owner,

            'pr_owner_username': pr.owner.username,

            'pr_username': user.username,

            'threading': threading,

        old_revisions = set(old_pull_request.revisions)

        revisions = self.create_action.revisions

        new_revisions = [r for r in revisions if r not in old_revisions]

        lost = old_revisions.difference(revisions)

        infos = ['This is a new iteration of %s "%s".' %

                      pull_request_id=old_pull_request.pull_request_id),

                  old_pull_request.title)]

        if lost:

            infos.append(_('Missing changesets since the previous iteration:'))

            for r in old_pull_request.revisions:

                if r in new_revisions:

                    rev_desc = org_repo.get_changeset(r).message.split('\n')[0]

                    infos.append('  %s %s' % (r[:12], h.shorter(rev_desc, 80)))

            if self.create_action.other_ref == old_pull_request.other_ref:

                infos.append(_("Ancestor didn't change - diff since previous iteration:"))

                                 repo_name=org_repo.repo_name, # other_repo is always same as repo_name

                                 org_ref_type='rev', org_ref_name=org_rev[:12], # use old org_rev as base

                                 other_ref_type='rev', other_ref_name=new_org_rev[:12],

                                 )) # note: linear diff, merge or not doesn't matter

            else:

                infos.append(_('This iteration is based on another %s revision and there is no simple diff.') % other_ref_name)

            return new_user

        except (DatabaseError,):

            log.error(traceback.format_exc())

            raise

    def create_registration(self, form_data):

        from kallithea.model.notification import NotificationModel

        form_data['admin'] = False

        form_data['extern_type'] = db.User.DEFAULT_AUTH_TYPE

        form_data['extern_name'] = ''

        new_user = self.create(form_data)

            'New user registration\n'

            '---------------------\n'

            '- Username: {user.username}\n'

            '- Full Name: {user.full_name}\n'

            '- Email: {user.email}\n'

            ).format(user=new_user)

        email_kwargs = {

            'registered_user_url': edit_url,

            'new_username': new_user.username,

            'new_email': new_user.email,

            'new_full_name': new_user.full_name}

        NotificationModel().create(created_by=new_user, subject=subject,

import datetime

import hashlib

import mock

from tg.util.webtest import test_context

from kallithea.lib.utils2 import AttributeDict, safe_bytes

from kallithea.model import db

from kallithea.tests import base

proto = 'http'

    ])

    def test_canonical_url(self, canonical, test, expected):

        # setup url(), used by canonical_url

        import routes

        from tg import request

        m = routes.Mapper()

        m.connect('about', '/about-page')

        url = routes.URLGenerator(m, {'HTTP_HOST': 'http_host.example.org'})

        config_mock = {

            'canonical_url': canonical,

        }

        with test_context(self.app):

            request.environ['routes.url'] = url

            with mock.patch('kallithea.CONFIG', config_mock):

    @base.parametrize('canonical,expected', [

        ('http://www.example.org', 'www.example.org'),

        ('http://www.example.org/repos/', 'www.example.org'),

        ('http://www.example.org/kallithea/repos/', 'www.example.org'),

    ])

    def test_canonical_hostname(self, canonical, expected):

        import routes

        from tg import request

        # setup url(), used by canonical_hostname

        m = routes.Mapper()

        url = routes.URLGenerator(m, {'HTTP_HOST': 'http_host.example.org'})

        config_mock = {

            'canonical_url': canonical,

        }

        with test_context(self.app):

            request.environ['routes.url'] = url

            with mock.patch('kallithea.CONFIG', config_mock):