.. _changelog:

Changelog

=========

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

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

- security bugfix simplehg wasn't checking for permissions on commands

  other than pull or push.

- fixed doubled messages after push or pull in admin journal

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.

    #sets the c attribute access when don't existing attribute are accessed

    config['pylons.strict_tmpl_context'] = True

    test = os.path.split(config['__file__'])[-1] == 'test.ini'

    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

    if config['debug'] and not test:

        #use query time debugging.

        from rhodecode.lib.timerproxy import TimerProxy

        if self.baseui:

            return self.baseui.configitems('paths')

    @LazyProperty

    def base_path(self):

        if self.baseui:

from rhodecode.lib.celerylib import run_task, locked_task

from rhodecode.lib.helpers import person

from rhodecode.lib.smtp_mailer import SmtpMailer

from rhodecode.lib.utils import OrderedDict

from time import mktime

from vcs.backends.hg import MercurialRepository

import traceback

try:

    import json

except ImportError:

    #python 2.5 compatibility

    import simplejson as json

    from rhodecode.model.db import Statistics, Repository

    log = get_commits_stats.get_logger()

    author_key_cleaner = lambda k: person(k).replace('"', "") #for js data compatibilty

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    skip_date_limit = True

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

    last_rev = 0

    last_cs = None

    timegetter = itemgetter('time')

    'aspx', 'asx', 'axd', 'c', 'cfg', 'cfm', 'cpp', 'cs', 'diff', 'do', 'el',

    'erl', 'h', 'java', 'js', 'jsp', 'jspx', 'lisp', 'lua', 'm', 'mako', 'ml',

    'pas', 'patch', 'php', 'php3', 'php4', 'phtml', 'pm', 'py', 'rb', 'rst',

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

    tip = repo.get_changeset()

    code_stats = {}

    def aggregate(cs):

        for f in cs[2]:

        web4.ui_key = 'baseurl'

        web4.ui_value = '/'

        paths = RhodeCodeUi()

        paths.ui_section = 'paths'

        paths.ui_key = '/'

        hgsettings1 = RhodeCodeSettings()

        hgsettings1.app_settings_name = 'realm'

        hgsettings1.app_settings_value = 'RhodeCode authentication'

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

# MERCURIAL FILTERS available via h.

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

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

email_or_none = lambda x: util.email(x) if util.email(x) != x else None

person = lambda x: _person(x)

hgdate = lambda  x: "%d %d" % x

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

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

# PERMS

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 webhelpers.html.builder import escape

from vcs.utils.lazy import LazyProperty

from whoosh.analysis import RegexTokenizer, LowercaseFilter, StopFilter

from whoosh.fields import TEXT, ID, STORED, Schema, FieldType

from whoosh.index import create_in, open_dir

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

#EXTENSIONS WE WANT TO INDEX CONTENT OFF

INDEX_EXTENSIONS = ['action', 'adp', 'ashx', 'asmx', 'aspx', 'asx', 'axd', 'c',

IDX_NAME = 'HG_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

        self.searcher = searcher

        self.matcher = matcher

        self.highlight_items = highlight_items

    def get_chunks(self):

        """

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

            start = span.startchar or 0

            end = span.endchar or 0

            start_offseted = max(0, start - self.fragment_size)

from os.path import join as jn

#to get the rhodecode import

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

import logging

# add formatter to ch

ch.setFormatter(formatter)

# 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

    def get_paths(self, repo):

        """

        recursive walk in root dir and return a set of all path in that dir

        based on repository walk function

        """

        index_paths_ = set()

        try:

                for f in files:

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

                for dir in dirs:

                    for f in files:

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

                        content=u_content,

                        modtime=self.get_node_mtime(node),

                        extension=node.extension)             

    def build_index(self):

            log.debug('removing previous index')

        writer = idx.writer()

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

            log.debug('building index @ %s' % repo.path)

            for idx_path in self.get_paths(repo):

        log.debug('>>> FINISHED BUILDING INDEX <<<')

    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

        to_index = set()

        reader = idx.reader()

    def run(self, full_index=False):

        """Run daemon"""

        if full_index or self.initial:

            self.build_index()

        else:

            self.update_index()

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

Utilities for RhodeCode

@author: marcink

"""

log = logging.getLogger(__name__)

def get_repo_slug(request):

    return request.environ['pylons.routes_dict'].get('repo_name')

        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_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):

        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)

    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)

    message = ''

    author = ''

    date = ''

    @LazyProperty

    def raw_id(self):

        """

        representation.

        """

        return '0' * 40

    @LazyProperty

    def short_id(self):

def repo2db_mapper(initial_repo_list, remove_obsolete=False):

    """

    maps all found repositories into db

    """

    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

                         }

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

                sa.delete(repo)

                sa.commit()

    meta.Session.remove()

class OrderedDict(dict, DictMixin):

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

        if len(args) > 1:

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

class Repository(Base):

    __tablename__ = 'repositories'

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

    fork_id = Column("fork_id", INTEGER(), ForeignKey(u'repositories.repo_id'), nullable=True, unique=False, default=None)

    user = relation('User')

            del['value']['user']

        return value

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

        def to_python(self, value, state):

            if old_data.get('email') != value:

                sa = meta.Session()

Created on April 9, 2010

Model for RhodeCode

@author: marcink

"""

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 rhodecode.model import meta

from rhodecode.model.db import Repository, User

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

def _get_repos_cached_initial(app_globals, initial):

    """return cached dict with repos

    """

    g = app_globals

@cache_region('long_term', 'cached_repo_list')

def _get_repos_cached():

    """return cached dict with repos

    """

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

    repos_lst = []

    for repo in [x for x in cached_repo_list.values()]:

        if HasRepoPermissionAny('repository.write', 'repository.read',

@cache_region('long_term', 'full_changelog')

def _full_changelog_cached(repo_name):

    log.info('getting full changelog for %s', repo_name)

    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:

                #name = name.split('/')[-1]

                if repos_list.has_key(name):

                    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:

                        log.info('Adding db instance to cached list')

                        repos_list[name].dbrepo = dbrepo

                        repos_list[name].description = dbrepo.description

                        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

            last_change = repo.last_change

            tip = h.get_changeset_safe(repo, 'tip')

		<th class="left">${_('tags')}</th>

		<th class="left">${_('links')}</th>

	</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>

			${h.link_to(h.truncate(cs.message,60),

			h.url('changeset_home',repo_name=c.repo_name,revision=cs.short_id),

			title=cs.message)}