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

    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(cache_key, *args):

    """

    Puts cache invalidation task into db for 

    further global cache invalidation

    """

    from rhodecode.model.scm import ScmModel

    if cache_key.startswith('get_repo_cached_'):

        name = cache_key.split('get_repo_cached_')[-1]

        ScmModel().mark_for_invalidation(name)

class EmptyChangeset(BaseChangeset):

    """

    An dummy empty changeset. It's possible to pass hash when creating

    an EmptyChangeset

# 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

Model for RhodeCode

@author: marcink

"""

from beaker.cache import cache_region, region_invalidate

from mercurial import ui

from rhodecode import BACKENDS

from rhodecode.lib import helpers as h

from rhodecode.lib.auth import HasRepoPermissionAny

from rhodecode.model import meta

from rhodecode.model.db import Repository, User, RhodeCodeUi, CacheInvalidation

from rhodecode.model.caching_query import FromCache

from sqlalchemy.orm import joinedload

from sqlalchemy.orm.session import make_transient

from vcs import get_backend

from vcs.utils.helpers import get_scm

from vcs.exceptions import RepositoryError, VCSError

from vcs.utils.lazy import LazyProperty

import traceback

import logging

import os

import time

log = logging.getLogger(__name__)

class ScmModel(object):

    """

    Mercurial Model

    """

    def __init__(self):

        self.sa = meta.Session()

    @LazyProperty

    def repos_path(self):

        """

        Get's the repositories root path from database

        """

        q = self.sa.query(RhodeCodeUi).filter(RhodeCodeUi.ui_key == '/').one()

        return q.ui_value

    def repo_scan(self, repos_path, baseui, initial=False):

        """

        Listing of repositories in given path. This path should not be a 

        repository itself. Return a dictionary of repository objects

        :param repos_path: path to directory containing repositories

        :param baseui

        :param initial: initial scan

        """

        log.info('scanning for repositories in %s', repos_path)

        if not isinstance(baseui, ui.ui):

        repos_list = {}

        for name, path in get_repos(repos_path):

            try:

                if repos_list.has_key(name):

                    raise RepositoryError('Duplicate repository name %s '

                                    'found in %s' % (name, path))

                else:

                    klass = get_backend(path[0])

                    if path[0] == 'hg' and path[0] in BACKENDS.keys():

                        repos_list[name] = klass(path[1], baseui=baseui)

                    if path[0] == 'git' and path[0] in BACKENDS.keys():

                        repos_list[name] = klass(path[1])

            except OSError:

                continue

        return repos_list

    def get_repos(self, all_repos=None):

        """

        Get all repos from db and for each repo create it's backend instance.