#!/usr/bin/env python

# encoding: utf-8

# RhodeCode, a web based repository management based on 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 9, 2010

RhodeCode, a web based repository management based on pylons

versioning implementation: http://semver.org/

@author: marcink

"""

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

def get_version():

    """

    Returns shorter version (digit parts only) as string.

    """

    return '.'.join((str(each) for each in VERSION[:3]))

        repo_name = repo.lstrip('/')

        user_log = UserLog()

        user_log.user_id = user_id

        user_log.action = action

        user_log.repository_name = repo_name

        user_log.repository = sa.query(Repository)\

            .filter(Repository.repo_name == repo_name).one()

        user_log.action_date = datetime.datetime.now()

        user_log.user_ip = ipaddr

        sa.add(user_log)

        sa.commit()

        log.info('Adding user %s, action %s on %s',

                                        user.username, action, repo)

    except Exception, e:

        sa.rollback()

        log.error('could not log user action:%s', str(e))

def check_repo_dir(paths):

    repos_path = paths[0][1].split('/')

    if repos_path[-1] in ['*', '**']:

        repos_path = repos_path[:-1]

    if repos_path[0] != '/':

        repos_path[0] = '/'

    if not os.path.isdir(os.path.join(*repos_path)):

        raise Exception('Not a valid repository in %s' % paths[0][1])

def check_repo_fast(repo_name, base_path):

    if os.path.isdir(os.path.join(base_path, repo_name)):return False

    return True

def check_repo(repo_name, base_path, verify=True):

    repo_path = os.path.join(base_path, repo_name)

    try:

        if not check_repo_fast(repo_name, base_path):

            return False

        r = hg.repository(ui.ui(), repo_path)

        if verify:

            hg.verify(r)

        #here we hnow that repo exists it was verified

        log.info('%s repo is already created', repo_name)

        return False

    except RepoError:

        #it means that there is no valid repo there...

        log.info('%s repo is free for creation', repo_name)

        return True

def ask_ok(prompt, retries=4, complaint='Yes or no, please!'):

    while True:

        ok = raw_input(prompt)

        if ok in ('y', 'ye', 'yes'): return True

        if ok in ('n', 'no', 'nop', 'nope'): return False

        retries = retries - 1

        if retries < 0: raise IOError

        print complaint

@cache_region('super_short_term', 'cached_hg_ui')

def get_hg_ui_cached():

    try:

        sa = meta.Session

        ret = sa.query(RhodeCodeUi).all()

    finally:

        meta.Session.remove()

    return ret

def get_hg_settings():

    try:

        sa = meta.Session

        ret = sa.query(RhodeCodeSettings).all()

    finally:

        meta.Session.remove()

    if not ret:

        raise Exception('Could not get application settings !')

    settings = {}

    for each in ret:

        settings['rhodecode_' + each.app_settings_name] = each.app_settings_value

    return settings

def get_hg_ui_settings():

    try:

        sa = meta.Session

        ret = sa.query(RhodeCodeUi).all()

    finally:

        meta.Session.remove()

    if not ret:

        raise Exception('Could not get application ui settings !')

    settings = {}

    for each in ret:

        k = each.ui_key

        v = each.ui_value

        if k == '/':

            k = 'root_path'

        if k.find('.') != -1:

            k = k.replace('.', '_')

        if each.ui_section == 'hooks':

            v = each.ui_active

        settings[each.ui_section + '_' + k] = v

    return settings

#propagated from mercurial documentation

ui_sections = ['alias', 'auth',

                'decode/encode', 'defaults',

                'diff', 'email',

                'extensions', 'format',

                'merge-patterns', 'merge-tools',

                'hooks', 'http_proxy',

                'smtp', 'patch',

                'paths', 'profiling',

                'server', 'trusted',

                'ui', 'web', ]

def make_ui(read_from='file', path=None, checkpaths=True):

    """

    A function that will read python rc files or database

    and make an mercurial ui object from read options

    :param path: path to mercurial config file

    :param checkpaths: check the path

    :param read_from: read from 'file' or 'db'

    """

    baseui = ui.ui()

    if read_from == 'file':

        if not os.path.isfile(path):

            log.warning('Unable to read config file %s' % path)

            return False

        log.debug('reading hgrc from %s', path)

        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_rhodecode_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 rhodecode.model.hg_model import _get_repos_cached

        region_invalidate(_get_repos_cached, None, *args)

    if name == 'full_changelog':

        from rhodecode.model.hg_model import _full_changelog_cached

        region_invalidate(_full_changelog_cached, None, *args)

class EmptyChangeset(BaseChangeset):

    """

    An dummy empty changeset.

    """

    revision = -1

    message = ''

    author = ''

    date = ''

    @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 get_file_changeset(self, path):

        return self

    def get_file_content(self, path):

        return u''

    def get_file_size(self, path):

        return 0

def repo2db_mapper(initial_repo_list, remove_obsolete=False):

    """

    maps all found repositories into db

    """

    from rhodecode.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):

        self.__end = end = []

        end += [None, end, end]         # sentinel node for doubly linked list

        self.__map = {}                 # key --> [key, prev, next]

        dict.clear(self)

    def __setitem__(self, key, value):

        if key not in self:

            end = self.__end

            curr = end[1]

            curr[2] = end[1] = self.__map[key] = [key, curr, end]

        dict.__setitem__(self, key, value)

    def __delitem__(self, key):

        dict.__delitem__(self, key)

        key, prev, next = self.__map.pop(key)

        prev[2] = next

        next[1] = prev

    def __iter__(self):

        end = self.__end

        curr = end[2]

        while curr is not end:

            yield curr[0]

            curr = curr[2]

    def __reversed__(self):

        end = self.__end

        curr = end[1]

        while curr is not end:

            yield curr[0]

            curr = curr[1]

    def popitem(self, last=True):

        if not self:

            raise KeyError('dictionary is empty')

        if last:

            key = reversed(self).next()

        else:

            key = iter(self).next()

        value = self.pop(key)

        return key, value

    def __reduce__(self):

        items = [[k, self[k]] for k in self]

        tmp = self.__map, self.__end

        del self.__map, self.__end

        inst_dict = vars(self).copy()

        self.__map, self.__end = tmp

        if inst_dict:

            return (self.__class__, (items,), inst_dict)

        return self.__class__, (items,)

    def keys(self):

        return list(self)

    setdefault = DictMixin.setdefault

    update = DictMixin.update

    pop = DictMixin.pop

    values = DictMixin.values

    items = DictMixin.items

    iterkeys = DictMixin.iterkeys

    itervalues = DictMixin.itervalues

    iteritems = DictMixin.iteritems

    def __repr__(self):

        if not self:

            return '%s()' % (self.__class__.__name__,)

        return '%s(%r)' % (self.__class__.__name__, self.items())

    def copy(self):

        return self.__class__(self)

    @classmethod

    def fromkeys(cls, iterable, value=None):

        d = cls()

        for key in iterable:

            d[key] = value

        return d

    def __eq__(self, other):

        if isinstance(other, OrderedDict):

            return len(self) == len(other) and self.items() == other.items()

        return dict.__eq__(self, other)

    def __ne__(self, other):

        return not self == other

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

# TEST FUNCTIONS

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

def create_test_index(repo_location, full_index):

    """Makes default test index

    :param repo_location:

    :param full_index:

    """

    from rhodecode.lib.indexers.daemon import WhooshIndexingDaemon

    from rhodecode.lib.pidlock import DaemonLock, LockHeld

    from rhodecode.lib.indexers import IDX_LOCATION

    import shutil

    if os.path.exists(IDX_LOCATION):

        shutil.rmtree(IDX_LOCATION)

    try:

        l = DaemonLock()

        WhooshIndexingDaemon(repo_location=repo_location)\

            .run(full_index=full_index)

        l.release()

    except LockHeld:

        pass

def create_test_env(repos_test_path, config):

    """Makes a fresh database and 

    install test repository into tmp dir

    """

    from rhodecode.lib.db_manage import DbManage

    import tarfile

    import shutil

    from os.path import dirname as dn, join as jn, abspath

    log = logging.getLogger('TestEnvCreator')

    # create logger

    log.setLevel(logging.DEBUG)

    log.propagate = True

    # create console handler and set level to debug

    ch = logging.StreamHandler()

    ch.setLevel(logging.DEBUG)

    # create formatter

    formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")

    # add formatter to ch

    ch.setFormatter(formatter)

    # add ch to logger

    log.addHandler(ch)

    #PART ONE create db

    dbname = config['sqlalchemy.db1.url'].split('/')[-1]

    log.debug('making test db %s', dbname)

    dbmanage = DbManage(log_sql=True, dbname=dbname, root=config['here'],

                        tests=True)

    dbmanage.create_tables(override=True)

    dbmanage.config_prompt(repos_test_path)

    dbmanage.create_default_user()

    dbmanage.admin_prompt()

    dbmanage.create_permissions()

    dbmanage.populate_default_permissions()

    #PART TWO make test repo

    log.debug('making test vcs repo')

    cur_dir = dn(dn(abspath(__file__)))

    tar = tarfile.open(jn(cur_dir, 'tests', "vcs_test.tar.gz"))

    tar.extractall('/tmp')

    tar.close()

##content highligthing

%for cnt,sr in enumerate(c.formated_results):

    %if h.HasRepoPermissionAny('repository.write','repository.read','repository.admin')(sr['repository'],'search results check'):

    <div class="table">

        <div id="body${cnt}" class="codeblock">

            <div class="code-header">

                <div class="revision">${h.link_to(h.literal('%s &raquo; %s' % (sr['repository'],sr['f_path'])),

                h.url('files_home',repo_name=sr['repository'],revision='tip',f_path=sr['f_path']))}</div>

            </div>

            <div class="code-body">

                <pre>${h.literal(sr['content_short_hl'])}</pre>

            </div>

        </div>

    </div>

    %else:

        %if cnt == 0:

        <div class="table">

            <div id="body${cnt}" class="codeblock">

                <div class="error">${_('Permission denied')}</div>

            </div>

        </div>      

        %endif

    %endif      

%endfor

%if c.cur_query and c.formated_results:

    ${c.formated_results.pager('$link_previous ~2~ $link_next')}

</div>  

%endif

"""Pylons application test package

This package assumes the Pylons environment is already loaded, such as

when this script is imported from the `nosetests --with-pylons=test.ini`

command.

This module initializes the application via ``websetup`` (`paster

setup-app`) and provides the base testing objects.

"""

from unittest import TestCase

from paste.deploy import loadapp

from paste.script.appinstall import SetupCommand

from pylons import config, url

from routes.util import URLGenerator

from webtest import TestApp

import os

from rhodecode.model import meta

import logging

import pylons.test

__all__ = ['environ', 'url', 'TestController']

# Invoke websetup with the current config file

#SetupCommand('setup-app').run([config_file])

##RUNNING DESIRED TESTS

#nosetests rhodecode.tests.functional.test_admin_settings:TestSettingsController.test_my_account

environ = {}

class TestController(TestCase):

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

        wsgiapp = pylons.test.pylonsapp

        config = wsgiapp.config

        self.app = TestApp(wsgiapp)

        url._push_object(URLGenerator(config['routes.map'], environ))

        self.sa = meta.Session

        TestCase.__init__(self, *args, **kwargs)

    def log_user(self, username='test_admin', password='test12'):

        response = self.app.post(url(controller='login', action='index'),

                                 {'username':username,

                                  'password':password})

        print response

        if 'invalid user name' in response.body:

            assert False, 'could not login using %s %s' % (username, password)

        assert response.status == '302 Found', 'Wrong response code from login got %s' % response.status

        assert response.session['rhodecode_user'].username == username, 'wrong logged in user got %s expected %s' % (response.session['rhodecode_user'].username, username)

        return response.follow()

from rhodecode.tests import *

class TestChangelogController(TestController):

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='changelog', action='index', repo_name='vcs_test'))

        assert """Small update at simplevcs app""" in response.body, 'missing info about commit message'

        assert """<span class="removed" title="removed">0</span>""" in response.body, 'wrong info about removed nodes'

        assert """<span class="changed" title="changed">2</span>""" in response.body, 'wrong info about changed nodes'

        assert """<span class="added" title="added">1</span>""" in response.body, 'wrong info about added nodes'

        #pagination

        response = self.app.get(url(controller='changelog', action='index', repo_name='vcs_test'), {'page':1})

        response = self.app.get(url(controller='changelog', action='index', repo_name='vcs_test'), {'page':2})

        response = self.app.get(url(controller='changelog', action='index', repo_name='vcs_test'), {'page':3})

        response = self.app.get(url(controller='changelog', action='index', repo_name='vcs_test'), {'page':4})

        response = self.app.get(url(controller='changelog', action='index', repo_name='vcs_test'), {'page':5})

        response = self.app.get(url(controller='changelog', action='index', repo_name='vcs_test'), {'page':6})

        # Test response after pagination...

        assert """<span class="removed" title="removed">20</span>"""in response.body, 'wrong info about number of removed'

        assert """<span class="changed" title="changed">1</span>"""in response.body, 'wrong info about number of changes'

        assert """<span class="added" title="added">0</span>"""in response.body, 'wrong info about number of added'

        assert """<div class="date">commit 64: 46ad32a4f974@2010-04-20 00:33:21</div>"""in response.body, 'wrong info about commit 64'

        assert """<div class="message"><a href="/vcs_test/changeset/46ad32a4f974">Merge with 2e6a2bf9356ca56df08807f4ad86d480da72a8f4</a></div>"""in response.body, 'wrong info about commit 64 is a merge'

[egg_info]

tag_svn_revision = true

[easy_install]

find_links = http://www.pylonshq.com/download/

[nosetests]

verbose=True

verbosity=2

with-pylons=test.ini

detailed-errors=1

# Babel configuration

[compile_catalog]

domain = rhodecode

directory = rhodecode/i18n

statistics = true

[extract_messages]

add_comments = TRANSLATORS:

output_file = rhodecode/i18n/rhodecode.pot

width = 80

[init_catalog]

domain = rhodecode

input_file = rhodecode/i18n/rhodecode.pot

output_dir = rhodecode/i18n

[update_catalog]

domain = rhodecode

input_file = rhodecode/i18n/rhodecode.pot

output_dir = rhodecode/i18n

previous = true

[build_sphinx]

source-dir = docs/

build-dir  = docs/_build

all_files  = 1

[upload_sphinx]

upload-dir = docs/_build/html

from rhodecode import get_version

import sys

py_version = sys.version_info

requirements = [

        "Pylons>=1.0.0",

        "Mako>=0.3.2",

        "vcs==0.1.8",

        "pygments>=1.3.0",

        "py-bcrypt",

        "babel",

    ]

                   'Environment :: Web Environment',

                   'Framework :: Pylons',

                   'Intended Audience :: Developers',

                   'License :: OSI Approved :: BSD License',

                   'Operating System :: OS Independent',

                   'Programming Language :: Python', ]

if sys.version_info < (2, 6):

    requirements.append("simplejson")

    requirements.append("pysqlite")

#additional files from project that goes somewhere in the filesystem

#relative to sys.prefix

data_files = []

#additional files that goes into package itself

package_data = {'rhodecode': ['i18n/*/LC_MESSAGES/*.mo', ], }

description = 'Mercurial repository serving and browsing app'

#long description

try:

    readme_file = 'README.rst'

    long_description = open(readme_file).read()

except IOError, err:

    sys.stderr.write("[WARNING] Cannot find file specified as "

        "long_description (%s)\n skipping that file" % readme_file)

    long_description = description

try:

    from setuptools import setup, find_packages

except ImportError:

    from ez_setup import use_setuptools

    use_setuptools()

    from setuptools import setup, find_packages

#packages

packages = find_packages(exclude=['ez_setup'])

setup(

    name='RhodeCode',

    version=get_version(),

    description=description,

    long_description=long_description,

    keywords='rhodiumcode mercurial web hgwebdir replacement serving hgweb rhodecode',

    license='BSD',

    author='Marcin Kuzminski',

    author_email='marcin@python-works.com',

    url='http://hg.python-works.com',

    install_requires=requirements,

    classifiers=classifiers,

    setup_requires=["PasteScript>=1.6.3"],

    data_files=data_files,

    packages=packages,

    include_package_data=True,

    test_suite='nose.collector',

    package_data=package_data,

    message_extractors={'rhodecode': [

            ('**.py', 'python', None),

            ('templates/**.mako', 'mako', {'input_encoding': 'utf-8'}),

            ('public/**', 'ignore', None)]},

    zip_safe=False,

    paster_plugins=['PasteScript', 'Pylons'],

    entry_points="""

    [paste.app_factory]

    main = rhodecode.config.middleware:make_app

    [paste.app_install]

    main = pylons.util:PylonsInstaller

    """,

)