incompatible

- setup-app will check for write permission in given path

- cleaned up license info issue #149

- fixes crashes on gravatar, when passed in email as unicode

- fixed tooltip flickering problems

- fixed came_from redirection on windows

- fixed logging modules,and sql formatters

1.1.7 (**2011-03-23**)

======================

from sqlalchemy.orm import relation, backref, class_mapper

from sqlalchemy.orm.session import Session

from rhodecode.model.meta import Base

from rhodecode.lib.dbmigrate.migrate import *

log = logging.getLogger(__name__)

def upgrade(migrate_engine):

    Don't create your own engine; bind migrate_engine to your metadata

    """

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

    # Upgrade of `user_logs` table

    tblname = 'users'

    tbl = Table(tblname, MetaData(bind=migrate_engine), autoload=True,

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

    # Upgrade of `repositories` table

    tblname = 'repositories'

    tbl = Table(tblname, MetaData(bind=migrate_engine), autoload=True,

                    autoload_with=migrate_engine)

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

    # Add table `user_followings`

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

    class UserFollowing(Base, BaseModel):

        __tablename__ = 'user_followings'

        __table_args__ = (UniqueConstraint('user_id', 'follows_repository_id'),

        follows_user = relation('User', primaryjoin='User.user_id==UserFollowing.follows_user_id')

        follows_repository = relation('Repository')

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

    # Add table `cache_invalidation`

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

    class CacheInvalidation(Base, BaseModel):

        __tablename__ = 'cache_invalidation'

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

        def __repr__(self):

            return "<CacheInvalidation('%s:%s')>" % (self.cache_id, self.cache_key)

    return

def downgrade(migrate_engine):

    meta = MetaData()

    meta.bind = migrate_engine

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

# GRAVATAR URL

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

from pylons import request

def gravatar_url(email_address, size=30):

    ~~~~~~~~~~~~~~~~~~~

    Hooks runned by rhodecode

    :created_on: Aug 6, 2010

    :author: marcink

    :license: GPLv3, see COPYING for more details.

"""

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

def repo_size(ui, repo, hooktype=None, **kwargs):

    """Presents size of repository after push

    :param ui:

    :param repo:

    :param hooktype:

def log_pull_action(ui, repo, **kwargs):

    """Logs user last pull action

    :param ui:

    :param repo:

    """

def log_push_action(ui, repo, **kwargs):

    """Maps user last push action to new changeset id, from mercurial

    :param ui:

    :param repo:

    """

    action_logger(username, action, repository, extra_params['ip'])

    return 0

import os

import sys

import traceback

#to get the rhodecode import

sys.path.append(dn(dn(dn(os.path.realpath(__file__)))))

from rhodecode.model import init_model

from rhodecode.model.scm import ScmModel

from rhodecode.config.environment import load_environment

        for docid in self.doc_ids:

            yield self.get_full_content(docid)

        """

        Slicing of resultWrapper

        """

        slice = []

        for docid in self.doc_ids[i:j]:

            slice.append(self.get_full_content(docid))

# 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, either version 3 of the License, or

#

# You should have received a copy of the GNU General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from mercurial.error import RepoError

from mercurial.hgweb import hgweb

from mercurial.hgweb.request import wsgiapplication

    def __init__(self, app):

        self.lock = threading.Lock()

        self.app = app

    def __call__(self, environ, start_response):

        with self.lock:

            profiler = cProfile.Profile()

                ##  Browsers don't mind this.

                resp += '<pre style="text-align:left; border-top: 4px dashed red; padding: 1em;">'

                resp += cgi.escape(out.getvalue(), True)

                output = StringIO()

                pprint.pprint(environ, output, depth=3)

                resp += cgi.escape(output.getvalue(), True)

                resp += '</pre>'

            return resp

"""

    rhodecode.lib.smtp_mailer

    ~~~~~~~~~~~~~~~~~~~~~~~~~

    Simple smtp mailer used in RhodeCode

    :created_on: Sep 13, 2010

    :copyright: (c) 2011 by marcink.

    :license: LICENSE_NAME, see LICENSE_FILE for more details.

class SmtpMailer(object):

    """SMTP mailer class

    mailer = SmtpMailer(mail_from, user, passwd, mail_server, mail_port, ssl, tls)

    :param recipients might be a list of string or single string

    """

    def __init__(self, mail_from, user, passwd, mail_server,

        self.mail_from = mail_from

        self.mail_server = mail_server

        self.passwd = passwd

        self.ssl = ssl

        self.tls = tls

    def send(self, recipients=[], subject='', body='', attachment_files=None):

    def get_content(self, msg_file):

        """Get content based on type, if content is a string do open first

        else just read because it's a probably open file object

        :param msg_file:

        """

        if isinstance(msg_file, str):

log = logging.getLogger(__name__)

def recursive_replace(str, replace=' '):

    """Recursive replace of given sign to just one instance

        str = str.replace(replace * 2, replace)

        return recursive_replace(str, replace)

def repo_name_slug(value):

    """Return slug of name of repository

    This function is called on each creation/modification

def get_repo_slug(request):

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

def action_logger(user, action, repo, ipaddr='', sa=None):

    """

    Action logger for various actions made by users

    :param user: user that made this action, can be a unique username string or

        object containing user_id attribute

    :param action: action to log, should be on of predefined unique actions for

        that action was made on

    :param ipaddr: optional ip address from what the action was made

    :param sa: optional sqlalchemy session

    """

    if not sa:

        else:

            raise Exception('You have to provide user object or username')

        rm = RepoModel()

        if hasattr(repo, 'repo_id'):

            repo_obj = rm.get(repo.repo_id, cache=False)

        else:

            raise Exception('You have to provide repository to action logger')

        user_log = UserLog()

        user_log.user_id = user_obj.user_id

        user_log.action = action

        log.error(traceback.format_exc())

        sa.rollback()

def get_repos(path, recursive=False, initial=False):

    """

    Scans given path for repos and return (name,(type,path)) tuple 

    Check given path for existence of directory

    :param repo_name:

    :param base_path:

    :return False: if this directory is present

    """

    return True

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

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

        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)

        retries = retries - 1

        print complaint

#propagated from mercurial documentation

                'server', 'trusted',

                'ui', 'web', ]

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

    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'

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

                baseui.setconfig(section, k, v)

    elif read_from == 'db':

        sa = meta.Session()

        ret = sa.query(RhodeCodeUi)\

    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

        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

    """

        self._empty_cs = cs

        self.revision = -1

        self.message = ''

        self.author = ''

        self.date = ''

    @LazyProperty

    def raw_id(self):

                sa.delete(repo)

                sa.commit()

class OrderedDict(dict, DictMixin):

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

#set cache regions for beaker so celery can utilise it

def add_cache(settings):

    for key in settings.keys():

        for prefix in ['beaker.cache.', 'cache.']:

            if key.startswith(prefix):

                                                             'memory')

            beaker.cache.cache_regions[region] = region_settings

def get_current_revision():

    """Returns tuple of (number, id) from repository containing this package

    or None if repository could not be found.

                      "was: %s" % err)

        return None

# TEST FUNCTIONS AND CREATORS

def create_test_index(repo_location, full_index):

    """Makes default test index

    :param repo_location:

    except LockHeld:

        pass

def create_test_env(repos_test_path, config):

    """Makes a fresh database and

    install test repository into tmp dir

    ch.setLevel(logging.DEBUG)

    # create formatter

    # add formatter to ch

    ch.setFormatter(formatter)

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

# PASTER COMMANDS

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

class BasePasterCommand(Command):

    """

    Abstract Base Class for paster commands.

        if log and isinstance(log, logging):

            log(msg)

    def run(self, args):

        """

        Overrides Command.run

################################################################################

################################################################################

#                                                                              # 

# The %(here)s variable will be replaced with the parent directory of this file#

################################################################################

################################################################################

## Uncomment and replace with the address which should receive                ## 

## any error reports after application crash                                  ##

################################################################################

#email_to = admin@localhost

#error_email_from = paste_error@localhost

full_stack = true

static_files = true

lang=en

index_dir = /tmp/index

cut_off_limit = 256000

force_https = false

celeryd.concurrency = 2

#celeryd.log.file = celeryd.log

celeryd.log.level = debug

#tasks will never be sent to the queue, but executed locally instead.

celery.always.eager = false

####################################

###         BEAKER CACHE        ####

####################################

beaker.cache.regions=super_short_term,short_term,long_term,sql_cache_short,sql_cache_med,sql_cache_long

beaker.cache.super_short_term.type=memory

### LOGGING CONFIGURATION   ####

################################

[loggers]

[handlers]

keys = console