Changelog

=========

1.0.0 (**2010-10-xx**)

----------------------

@author: marcink

"""

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

    if test:

        from rhodecode.lib.utils import create_test_env, create_test_index

        create_test_env('/tmp', config)

    #MULTIPLE DB configs

    # Setup the SQLAlchemy database engine

    @LazyProperty

    def base_path(self):

        if self.baseui:

from rhodecode.lib.utils import OrderedDict

from time import mktime

from vcs.backends.hg import MercurialRepository

import traceback

try:

    import json

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    skip_date_limit = True

    parse_limit = 250 #limit for single task changeset parsing optimal for

    's', 'sh', 'tpl', 'txt', 'vim', 'wss', 'xhtml', 'xml', 'xsl', 'xslt', 'yaws']

    tip = repo.get_changeset()

    code_stats = {}

        paths = RhodeCodeUi()

        paths.ui_section = 'paths'

        paths.ui_key = '/'

        hgsettings1 = RhodeCodeSettings()

from mercurial import util

from mercurial.templatefilters import age as _age, person as _person

capitalize = lambda x: x.capitalize()

date = lambda x: util.datestr(x)

email = util.email

isodate = lambda  x: util.datestr(x, '%Y-%m-%d %H:%M %1%2')

isodatesec = lambda  x: util.datestr(x, '%Y-%m-%d %H:%M:%S %1%2')

localdate = lambda  x: (x[0], util.makedate()[1])

rfc3339date = lambda  x: util.datestr(x, "%Y-%m-%dT%H:%M:%S%1:%2")

time_ago = lambda x: util.datestr(_age(x), "%a, %d %b %Y %H:%M:%S %1%2")

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

from rhodecode.config.environment import load_environment

from rhodecode.model.hg import HgModel

from shutil import rmtree

from whoosh.formats import Characters

from whoosh.highlight import highlight, SimpleFragmenter, HtmlFormatter   

import traceback

#LOCATION WE KEEP THE INDEX

IDX_LOCATION = jn(dn(dn(dn(dn(os.path.abspath(__file__))))), 'data', 'index')

FORMATTER = HtmlFormatter('span', between='\n<span class="break">...</span>\n') 

FRAGMENTER = SimpleFragmenter(200)

class ResultWrapper(object):

    def __init__(self, search_type, searcher, matcher, highlight_items):

        self.search_type = search_type

        Smart function that implements chunking the content

        but not overlap chunks so it doesn't highlight the same

        close occurrences twice.

        """

        memory = [(0, 0)]

        for span in self.matcher.spans():

project_path = dn(dn(dn(dn(os.path.realpath(__file__)))))

sys.path.append(project_path)

from rhodecode.model.hg import HgModel

from rhodecode.lib.helpers import safe_unicode

from whoosh.index import create_in, open_dir

from shutil import rmtree

from time import mktime

from vcs.exceptions import ChangesetError, RepositoryError

# add ch to logger

log.addHandler(ch)

class WhooshIndexingDaemon(object):

    """

    Deamon for atomic jobs

    """

        self.indexname = indexname

        self.repo_location = repo_location

        self.initial = False

            log.info('Cannot run incremental index since it does not'

                     ' yet exist running full build')

            self.initial = True

        """

        index_paths_ = set()

        try:

                for f in files:

                    index_paths_.add(jn(repo.path, f.path))

                for dir in dirs:

    def build_index(self):

            log.debug('removing previous index')

        writer = idx.writer()

        for cnt, repo in enumerate(self.repo_paths.values()):

    def update_index(self):

        log.debug('STARTING INCREMENTAL INDEXING UPDATE')

        # The set of all paths in the index

        indexed_paths = set()

        # The set of all paths we need to re-index

            self.build_index()

        else:

            self.update_index()

# 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 18, 2010

Utilities for RhodeCode

@author: marcink

"""

log = logging.getLogger(__name__)

        sa.rollback()

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

def check_repo_fast(repo_name, base_path):

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

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

                baseui.setconfig(section, k, v)

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

    elif read_from == 'db':

        hg_ui = get_hg_ui_cached()

    @LazyProperty

    def raw_id(self):

        """

        representation.

        """

        return '0' * 40

    """

    sa = meta.Session()

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

            form_data = {

                         'repo_name':name,

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

                                        'auto description for %s' % name,

                         'private':False

    meta.Session.remove()

class OrderedDict(dict, DictMixin):

    __table_args__ = (UniqueConstraint('repo_name'), {'useexisting':True},)

    repo_id = Column("repo_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)

    repo_name = Column("repo_name", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=False, unique=True, default=None)

    user_id = Column("user_id", INTEGER(), ForeignKey(u'users.user_id'), nullable=False, unique=False, default=None)

    private = Column("private", BOOLEAN(), nullable=True, unique=None, default=None)

    description = Column("description", TEXT(length=None, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

class ValidPath(formencode.validators.FancyValidator):

    def to_python(self, value, state):

            msg = _('This is not a valid path')

        raise formencode.Invalid(msg, value, state,

                                     error_dict={'paths_root_path':msg})

def UniqSystemEmail(old_data):

    class _UniqSystemEmail(formencode.validators.FancyValidator):

"""

from beaker.cache import cache_region

from mercurial import ui

from rhodecode.lib import helpers as h

from rhodecode.lib.utils import invalidate_cache

from rhodecode.lib.auth import HasRepoPermissionAny

from sqlalchemy.orm import joinedload

from vcs.exceptions import RepositoryError, VCSError

import logging

import sys

log = logging.getLogger(__name__)

try:

    from vcs.backends.hg import MercurialRepository

except ImportError:

    sys.stderr.write('You have to import vcs module')

    raise Exception('Unable to import vcs')

    """return cached dict with repos

    """

    g = app_globals

@cache_region('long_term', 'cached_repo_list')

def _get_repos_cached():

    """

    log.info('getting all repositories list')

    from pylons import app_globals as g

@cache_region('super_short_term', 'cached_repos_switcher_list')

def _get_repos_switcher_cached(cached_repo_list):

    return list(reversed(list(HgModel().get_repo(repo_name))))

class HgModel(object):

    """

        """

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

        repository itself. Return a dictionary of repository objects

            """

        if not isinstance(baseui, ui.ui):

            baseui = ui.ui()

        repos_list = {}

        for name, path in repos:

            try:

                    raise RepositoryError('Duplicate repository name %s found in'

                                    ' %s' % (name, path))

                else:

                    repos_list[name].name = name

                    dbrepo = None

                    if not initial:

                        #for initial scann on application first run we don't

                        #have db repos yet.

                            .options(joinedload(Repository.fork))\

                            .filter(Repository.repo_name == name)\

                            .scalar()

                        if dbrepo.user:

                            repos_list[name].contact = dbrepo.user.full_contact

                        else:

                            .filter(User.admin == True).first().full_contact

            except OSError:

                continue

        return repos_list

    def get_repos(self):

        for name, repo in _get_repos_cached().items():

                #skip hidden web repository

                continue

	</tr>

%for cnt,cs in enumerate(c.repo_changesets):

	<tr class="parity${cnt%2}">

		<td title="${cs.author}">${h.person(cs.author)}</td>

		<td>r${cs.revision}:${cs.short_id}</td>

		<td>