@author: marcink

"""

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

from pylons.i18n.translation import _

from pylons.controllers.util import redirect

from pylons_app.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from pylons_app.lib.base import BaseController, render

from pylons_app.model.hg_model import HgModel

from vcs.exceptions import RepositoryError, ChangesetError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

import logging

import traceback

log = logging.getLogger(__name__)

class ChangesetController(BaseController):

    @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 * 100

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

            return redirect(url('hg_home'))

        else:

            try:

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

            except IndexError:

                c.changeset_old = None

            c.changes = []

            c.sum_added = 0

            for node in c.changeset.added:

                filenode_old = FileNode(node.path, '')

                if filenode_old.is_binary or node.is_binary:

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

                else:

                    if c.sum_added < cut_off_limit:

                        f_udiff = differ.get_udiff(filenode_old, node)

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

                    else:

                cs1 = None

                cs2 = node.last_changeset.short_id                                        

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

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

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

                    else:

                cs1 = filenode_old.last_changeset.short_id

                cs2 = node.last_changeset.short_id                    

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

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

            return redirect(url('hg_home'))

        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

                cs2 = node.last_changeset.short_id                                        

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

                cs1 = filenode_old.last_changeset.short_id

                cs2 = node.last_changeset.short_id                    

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

        response.content_type = 'text/plain'

        if method == 'download':

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

#!/usr/bin/env python

# encoding: utf-8

# files controller for pylons

# Copyright (C) 2009-2010 Marcin Kuzminski <marcin@python-works.com>

# This program is free software; you can redistribute it and/or

# modify it under the terms of the GNU General Public License

# as published by the Free Software Foundation; version 2

# 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 April 21, 2010

files controller for pylons

@author: marcink

"""

from mercurial import archival

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

from pylons.controllers.util import redirect

from pylons_app.lib.auth import LoginRequired, HasRepoPermissionAnyDecorator

from pylons_app.lib.base import BaseController, render

from pylons_app.lib.utils import EmptyChangeset

from pylons_app.model.hg_model import HgModel

from vcs.exceptions import RepositoryError, ChangesetError

from vcs.nodes import FileNode

from vcs.utils import diffs as differ

import logging

import pylons_app.lib.helpers as h

import tempfile

log = logging.getLogger(__name__)

class FilesController(BaseController):

    @LoginRequired()

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

                                   'repository.admin')       

    def __before__(self):

        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

            prev_rev = repo.get_changeset(get_prev_rev(cur_rev)).short_id

            next_rev = repo.get_changeset(get_next_rev(cur_rev)).short_id

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

        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.cur_rev = cs.short_id

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

        repo = HgModel().get_repo(repo_name).repo

        fname = '%s-%s%s' % (repo_name, revision, fileformat)

        archival.archive(repo, archive, revision, archive_specs[fileformat][1],

                         prefix='%s-%s' % (repo_name, revision))

        response.content_type = archive_specs[fileformat][0]

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

        archive.seek(0)

        return read_in_chunks(archive)

    def diff(self, repo_name, f_path):

        hg_model = HgModel()

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

        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:

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

                node1 = c.changeset_1.get_node(f_path)

            else:

                c.changeset_1 = EmptyChangeset()

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

                node2 = c.changeset_2.get_node(f_path)

            else:

                c.changeset_2 = EmptyChangeset()

        except RepositoryError:

            return redirect(url('files_home',

                                repo_name=c.repo_name, f_path=f_path))

        c.diff1 = 'r%s:%s' % (c.changeset_1.revision, c.changeset_1.short_id)

        c.diff2 = 'r%s:%s' % (c.changeset_2.revision, c.changeset_2.short_id)

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

            c.cur_diff = diff.as_html()

        else:

            #default option

            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)

            hist_l.append((chs.short_id, n_desc,))

        return hist_l

        cfg = config.config()

        cfg.read(path)

        for section in ui_sections:

            for k, v in cfg.items(section):

                baseui.setconfig(section, k, v)

                log.debug('settings ui from file[%s]%s:%s', section, k, v)

        if checkpaths:check_repo_dir(cfg.items('paths'))                

    elif read_from == 'db':

        hg_ui = get_hg_ui_cached()

        for ui_ in hg_ui:

            if ui_.ui_active:

                log.debug('settings ui from db[%s]%s:%s', ui_.ui_section, ui_.ui_key, ui_.ui_value)

                baseui.setconfig(ui_.ui_section, ui_.ui_key, ui_.ui_value)

    return baseui

def set_hg_app_config(config):

    hgsettings = get_hg_settings()

    for k, v in hgsettings.items():

        config[k] = v

def invalidate_cache(name, *args):

    """Invalidates given name cache"""

    from beaker.cache import region_invalidate

    log.info('INVALIDATING CACHE FOR %s', name)

    """propagate our arguments to make sure invalidation works. First

    argument has to be the name of cached func name give to cache decorator

    without that the invalidation would not work"""

    tmp = [name]

    tmp.extend(args)

    args = tuple(tmp)

    if name == 'cached_repo_list':

        from pylons_app.model.hg_model import _get_repos_cached

        region_invalidate(_get_repos_cached, None, *args)

    if name == 'full_changelog':

        from pylons_app.model.hg_model import _full_changelog_cached

        region_invalidate(_full_changelog_cached, None, *args)

class EmptyChangeset(BaseChangeset):

    revision = -1

    message = ''

    author = ''

    @LazyProperty

    def raw_id(self):

        """

        Returns raw string identifing this changeset, useful for web

        representation.

        """

        return '0' * 40

    @LazyProperty

    def short_id(self):

        return self.raw_id[:12]

def repo2db_mapper(initial_repo_list, remove_obsolete=False):

    """

    maps all found repositories into db

    """

    from pylons_app.model.repo_model import RepoModel

    sa = meta.Session

    user = sa.query(User).filter(User.admin == True).first()

    rm = RepoModel()

    for name, repo in initial_repo_list.items():

        if not sa.query(Repository).filter(Repository.repo_name == name).scalar():

            log.info('repository %s not found creating default', name)

            form_data = {

                         'repo_name':name,

                         'description':repo.description if repo.description != 'unknown' else \

                                        'auto description for %s' % name,

                         'private':False

                         }

            rm.create(form_data, user, just_db=True)

    if remove_obsolete:

        #remove from database those repositories that are not in the filesystem

        for repo in sa.query(Repository).all():

            if repo.repo_name not in initial_repo_list.keys():

                sa.delete(repo)

                sa.commit()

    meta.Session.remove()

from UserDict import DictMixin

class OrderedDict(dict, DictMixin):

    def __init__(self, *args, **kwds):

        if len(args) > 1:

            raise TypeError('expected at most 1 arguments, got %d' % len(args))

        try:

            self.__end

        except AttributeError:

            self.clear()

        self.update(*args, **kwds)

    def clear(self):