while curr_key != _nil:

            _, val, curr_key = dict_impl.__getitem__(self, curr_key)

            yield val

    def values(self):

        return list(self.itervalues())

    def iteritems(self):

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lh')

        while curr_key != _nil:

            _, val, next_key = dict_impl.__getitem__(self, curr_key)

            yield curr_key, val

            curr_key = next_key

    def items(self):

        return list(self.iteritems())

    def sort(self, cmp=None, key=None, reverse=False):

        items = [(k, v) for k, v in self.items()]

        if cmp is not None:

            items = sorted(items, cmp=cmp)

        elif key is not None:

            items = sorted(items, key=key)

        else:

            items = sorted(items, key=lambda x: x[1])

        if reverse:

            items.reverse()

        self.clear()

        self.__init__(items)

    def clear(self):

        dict_impl = self._dict_impl()

        dict_impl.clear(self)

        dict_impl.__setattr__(self, 'lh', _nil)

        dict_impl.__setattr__(self, 'lt', _nil)

    def copy(self):

        return self.__class__(self)

    def update(self, data=(), **kwds):

        if kwds:

            raise TypeError("update() of ordered dict takes no keyword "

                            "arguments to avoid an ordering trap.")

        if hasattr(data, "iteritems"):

            data = data.iteritems()

        for key, val in data:

            self[key] = val

    def setdefault(self, k, x=None):

        try:

            return self[k]

        except KeyError:

            self[k] = x

            return x

    def pop(self, k, x=_nil):

        try:

            val = self[k]

            del self[k]

            return val

        except KeyError:

            if x == _nil:

                raise

            return x

    def popitem(self):

        try:

            dict_impl = self._dict_impl()

            key = dict_impl.__getattribute__(self, 'lt')

            return key, self.pop(key)

        except KeyError:

            raise KeyError("'popitem(): ordered dictionary is empty'")

    def riterkeys(self):

        """To iterate on keys in reversed order.

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            yield curr_key

            curr_key = dict_impl.__getitem__(self, curr_key)[0]

    __reversed__ = riterkeys

    def rkeys(self):

        """List of the keys in reversed order.

        """

        return list(self.riterkeys())

    def ritervalues(self):

        """To iterate on values in reversed order.

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            curr_key, val, _ = dict_impl.__getitem__(self, curr_key)

            yield val

    def rvalues(self):

        """List of the values in reversed order.

        """

        return list(self.ritervalues())

    def riteritems(self):

        """To iterate on (key, value) in reversed order.

        """

        dict_impl = self._dict_impl()

        curr_key = dict_impl.__getattribute__(self, 'lt')

        while curr_key != _nil:

            pred_key, val, _ = dict_impl.__getitem__(self, curr_key)

            yield curr_key, val

            curr_key = pred_key

    def ritems(self):

        """List of the (key, value) in reversed order.

        """

        return list(self.riteritems())

    def firstkey(self):

        if self:

            return self._dict_impl().__getattribute__(self, 'lh')

        else:

            raise KeyError("'firstkey(): ordered dictionary is empty'")

    def lastkey(self):

        if self:

            return self._dict_impl().__getattribute__(self, 'lt')

        else:

            raise KeyError("'lastkey(): ordered dictionary is empty'")

    def as_dict(self):

        return self._dict_impl()(self.items())

    def _repr(self):

        """_repr(): low level repr of the whole data contained in the odict.

        Useful for debugging.

        """

        dict_impl = self._dict_impl()

        form = "odict low level repr lh,lt,data: %r, %r, %s"

        return form % (dict_impl.__getattribute__(self, 'lh'),

                       dict_impl.__getattribute__(self, 'lt'),

                       dict_impl.__repr__(self))

class OrderedDict(_odict, dict):

    def _dict_impl(self):

        return dict

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

# OrderedSet

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

from sqlalchemy.util import OrderedSet

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

# kill FUNCTIONS

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

if __platform__ in PLATFORM_WIN:

    import ctypes

    def kill(pid, sig):

        """kill function for Win32"""

        kernel32 = ctypes.windll.kernel32

        handle = kernel32.OpenProcess(1, 0, pid)

        return (0 != kernel32.TerminateProcess(handle, 0))

else:

    kill = os.kill

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

# itertools.product

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

try:

    from itertools import product

except ImportError:

    def product(*args, **kwds):

        # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy

        # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111

        pools = map(tuple, args) * kwds.get('repeat', 1)

        result = [[]]

        for pool in pools:

            result = [x + [y] for x in result for y in pool]

        for prod in result:

            yield tuple(prod)

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

# BytesIO

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

try:

    from io import BytesIO

except ImportError:

    from cStringIO import StringIO as BytesIO

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

# bytes

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

if __py_version__ >= (2, 6):

    _bytes = bytes

else:

    # in py2.6 bytes is a synonim for str

    _bytes = str

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

# deque

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

if __py_version__ >= (2, 6):

    from collections import deque

else:

    #need to implement our own deque with maxlen

    class deque(object):

        def __init__(self, iterable=(), maxlen= -1):

            if not hasattr(self, 'data'):

                self.left = self.right = 0

                self.data = {}

            self.maxlen = maxlen or -1

            self.extend(iterable)

        def append(self, x):

            self.data[self.right] = x

            self.right += 1

            if self.maxlen != -1 and len(self) > self.maxlen:

                self.popleft()

        def appendleft(self, x):

            self.left -= 1

            self.data[self.left] = x

            if self.maxlen != -1 and len(self) > self.maxlen:

                self.pop()

        def pop(self):

            if self.left == self.right:

                raise IndexError('cannot pop from empty deque')

            self.right -= 1

            elem = self.data[self.right]

            del self.data[self.right]

            return elem

        def popleft(self):

            if self.left == self.right:

                raise IndexError('cannot pop from empty deque')

            elem = self.data[self.left]

            del self.data[self.left]

            self.left += 1

            return elem

        def clear(self):

            self.data.clear()

            self.left = self.right = 0

        def extend(self, iterable):

            for elem in iterable:

                self.append(elem)

        def extendleft(self, iterable):

            for elem in iterable:

                self.appendleft(elem)

        def rotate(self, n=1):

            if self:

                n %= len(self)

                for i in xrange(n):

                    self.appendleft(self.pop())

        def __getitem__(self, i):

            if i < 0:

                i += len(self)

            try:

                return self.data[i + self.left]

            except KeyError:

                raise IndexError

        def __setitem__(self, i, value):

            if i < 0:

                i += len(self)

            try:

                self.data[i + self.left] = value

            except KeyError:

                raise IndexError

        def __delitem__(self, i):

            size = len(self)

            if not (-size <= i < size):

                raise IndexError

            data = self.data

            if i < 0:

                i += size

            for j in xrange(self.left + i, self.right - 1):

                data[j] = data[j + 1]

            self.pop()

        def __len__(self):

            return self.right - self.left

        def __cmp__(self, other):

            if type(self) != type(other):

                return cmp(type(self), type(other))

            return cmp(list(self), list(other))

        def __repr__(self, _track=[]):

            if id(self) in _track:

                return '...'

            _track.append(id(self))

            r = 'deque(%r, maxlen=%s)' % (list(self), self.maxlen)

            _track.remove(id(self))

            return r

        def __getstate__(self):

            return (tuple(self),)

        def __setstate__(self, s):

            self.__init__(s[0])

        def __hash__(self):

            raise TypeError

        def __copy__(self):

            return self.__class__(self)

        def __deepcopy__(self, memo={}):

            from copy import deepcopy

            result = self.__class__()

            memo[id(self)] = result

            result.__init__(deepcopy(tuple(self), memo))

            return result

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

# threading.Event

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

if __py_version__ >= (2, 6):

    from threading import Event, Thread

else:

    from threading import _Verbose, Condition, Lock, Thread

    def Event(*args, **kwargs):

        return _Event(*args, **kwargs)

    class _Event(_Verbose):

        # After Tim Peters' event class (without is_posted())

        def __init__(self, verbose=None):

            _Verbose.__init__(self, verbose)

            self.__cond = Condition(Lock())

            self.__flag = False

        def isSet(self):

            return self.__flag

        is_set = isSet

        def set(self):

            self.__cond.acquire()

            try:

                self.__flag = True

                self.__cond.notify_all()

            finally:

                self.__cond.release()

        def clear(self):

            self.__cond.acquire()

            try:

                self.__flag = False

            finally:

                self.__cond.release()

        def wait(self, timeout=None):

            self.__cond.acquire()

            try:

                if not self.__flag:

                    self.__cond.wait(timeout)

            finally:

                self.__cond.release()

    __table_args__ = (

        UniqueConstraint('user_id', 'permission_id'),

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'}

    )

    user_to_perm_id = Column("user_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

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

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    user = relationship('User')

    permission = relationship('Permission', lazy='joined')

class UsersGroupRepoToPerm(Base, BaseModel):

    __tablename__ = 'users_group_repo_to_perm'

    __table_args__ = (

        UniqueConstraint('repository_id', 'users_group_id', 'permission_id'),

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'}

    )

    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UsersGroup')

    permission = relationship('Permission')

    repository = relationship('Repository')

    @classmethod

    def create(cls, users_group, repository, permission):

        n = cls()

        n.users_group = users_group

        n.repository = repository

        n.permission = permission

        Session.add(n)

        return n

    def __unicode__(self):

        return u'<userGroup:%s => %s >' % (self.users_group, self.repository)

class UsersGroupToPerm(Base, BaseModel):

    __tablename__ = 'users_group_to_perm'

    __table_args__ = (

        UniqueConstraint('users_group_id', 'permission_id',),

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'}

    )

    users_group_to_perm_id = Column("users_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UsersGroup')

    permission = relationship('Permission')

class UserRepoGroupToPerm(Base, BaseModel):

    __tablename__ = 'user_repo_group_to_perm'

    __table_args__ = (

        UniqueConstraint('user_id', 'group_id', 'permission_id'),

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'}

    )

    group_to_perm_id = Column("group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

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

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    user = relationship('User')

    group = relationship('RepoGroup')

    permission = relationship('Permission')

class UsersGroupRepoGroupToPerm(Base, BaseModel):

    __tablename__ = 'users_group_repo_group_to_perm'

    __table_args__ = (

        UniqueConstraint('users_group_id', 'group_id'),

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'}

    )

    users_group_repo_group_to_perm_id = Column("users_group_repo_group_to_perm_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    users_group_id = Column("users_group_id", Integer(), ForeignKey('users_groups.users_group_id'), nullable=False, unique=None, default=None)

    group_id = Column("group_id", Integer(), ForeignKey('groups.group_id'), nullable=False, unique=None, default=None)

    permission_id = Column("permission_id", Integer(), ForeignKey('permissions.permission_id'), nullable=False, unique=None, default=None)

    users_group = relationship('UsersGroup')

    permission = relationship('Permission')

    group = relationship('RepoGroup')

class Statistics(Base, BaseModel):

    __tablename__ = 'statistics'

    __table_args__ = (

         UniqueConstraint('repository_id'),

         {'extend_existing': True, 'mysql_engine':'InnoDB',

          'mysql_charset': 'utf8'}

    )

    stat_id = Column("stat_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    repository_id = Column("repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=False, unique=True, default=None)

    stat_on_revision = Column("stat_on_revision", Integer(), nullable=False)

    commit_activity = Column("commit_activity", LargeBinary(1000000), nullable=False)#JSON data

    commit_activity_combined = Column("commit_activity_combined", LargeBinary(), nullable=False)#JSON data

    languages = Column("languages", LargeBinary(1000000), nullable=False)#JSON data

    repository = relationship('Repository', single_parent=True)

class UserFollowing(Base, BaseModel):

    __tablename__ = 'user_followings'

    __table_args__ = (

        UniqueConstraint('user_id', 'follows_repository_id'),

        UniqueConstraint('user_id', 'follows_user_id'),

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'}

    )

    user_following_id = Column("user_following_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

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

    follows_repo_id = Column("follows_repository_id", Integer(), ForeignKey('repositories.repo_id'), nullable=True, unique=None, default=None)

    follows_user_id = Column("follows_user_id", Integer(), ForeignKey('users.user_id'), nullable=True, unique=None, default=None)

    follows_from = Column('follows_from', DateTime(timezone=False), nullable=True, unique=None, default=datetime.datetime.now)

    user = relationship('User', primaryjoin='User.user_id==UserFollowing.user_id')

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

    follows_repository = relationship('Repository', order_by='Repository.repo_name')

    @classmethod

    def get_repo_followers(cls, repo_id):

        return cls.query().filter(cls.follows_repo_id == repo_id)

class CacheInvalidation(Base, BaseModel):

    __tablename__ = 'cache_invalidation'

    __table_args__ = (

        UniqueConstraint('cache_key'),

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    cache_id = Column("cache_id", Integer(), nullable=False, unique=True, default=None, primary_key=True)

    cache_key = Column("cache_key", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    cache_args = Column("cache_args", String(length=255, convert_unicode=False, assert_unicode=None), nullable=True, unique=None, default=None)

    cache_active = Column("cache_active", Boolean(), nullable=True, unique=None, default=False)

    def __init__(self, cache_key, cache_args=''):

        self.cache_key = cache_key

        self.cache_args = cache_args

        self.cache_active = False

    def __unicode__(self):

        return u"<%s('%s:%s')>" % (self.__class__.__name__,

                                  self.cache_id, self.cache_key)

    @classmethod

    def clear_cache(cls):

        cls.query().delete()

    @classmethod

    def _get_key(cls, key):

        """

        Wrapper for generating a key, together with a prefix

        :param key:

        """

        import rhodecode

        prefix = ''

        iid = rhodecode.CONFIG.get('instance_id')

        if iid:

            prefix = iid

        return "%s%s" % (prefix, key), prefix, key.rstrip('_README')

    @classmethod

    def get_by_key(cls, key):

        return cls.query().filter(cls.cache_key == key).scalar()

    @classmethod

    def _get_or_create_key(cls, key, prefix, org_key):

        inv_obj = Session.query(cls).filter(cls.cache_key == key).scalar()

        if not inv_obj:

            try:

                inv_obj = CacheInvalidation(key, org_key)

                Session.add(inv_obj)

                Session.commit()

            except Exception:

                log.error(traceback.format_exc())

                Session.rollback()

        return inv_obj

    @classmethod

    def invalidate(cls, key):

        """

        Returns Invalidation object if this given key should be invalidated

        None otherwise. `cache_active = False` means that this cache

        state is not valid and needs to be invalidated

        :param key:

        """

        key, _prefix, _org_key = cls._get_key(key)

        inv = cls._get_or_create_key(key, _prefix, _org_key)

        if inv and inv.cache_active is False:

            return inv

    @classmethod

    def set_invalidate(cls, key):

        """

        Mark this Cache key for invalidation

        :param key:

        """

        key, _prefix, _org_key = cls._get_key(key)

        inv_objs = Session.query(cls).filter(cls.cache_args == _org_key).all()

        log.debug('marking %s key[s] %s for invalidation' % (len(inv_objs),

                                                             _org_key))

        try:

            for inv_obj in inv_objs:

                if inv_obj:

                    inv_obj.cache_active = False

                Session.add(inv_obj)

            Session.commit()

        except Exception:

            log.error(traceback.format_exc())

            Session.rollback()

    @classmethod

    def set_valid(cls, key):

        """

        Mark this cache key as active and currently cached

        :param key:

        """

        inv_obj = cls.get_by_key(key)

        inv_obj.cache_active = True

        Session.add(inv_obj)

        Session.commit()

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    comment_id = Column('comment_id', Integer(), nullable=False, primary_key=True)

    repo_id = Column('repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    revision = Column('revision', String(40), nullable=False)

    line_no = Column('line_no', Unicode(10), nullable=True)

    f_path = Column('f_path', Unicode(1000), nullable=True)

    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), nullable=False)

    text = Column('text', Unicode(25000), nullable=False)

    modified_at = Column('modified_at', DateTime(), nullable=False, default=datetime.datetime.now)

    author = relationship('User', lazy='joined')

    repo = relationship('Repository')

    @classmethod

    def get_users(cls, revision):

        """

        Returns user associated with this changesetComment. ie those

        who actually commented

        :param cls:

        :param revision:

        """

        return Session.query(User)\

                .filter(cls.revision == revision)\

                .join(ChangesetComment.author).all()

class Notification(Base, BaseModel):

    __tablename__ = 'notifications'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    TYPE_CHANGESET_COMMENT = u'cs_comment'

    TYPE_MESSAGE = u'message'

    TYPE_MENTION = u'mention'

    TYPE_REGISTRATION = u'registration'

    notification_id = Column('notification_id', Integer(), nullable=False, primary_key=True)

    subject = Column('subject', Unicode(512), nullable=True)

    body = Column('body', Unicode(50000), nullable=True)

    created_by = Column("created_by", Integer(), ForeignKey('users.user_id'), nullable=True)

    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    type_ = Column('type', Unicode(256))

    created_by_user = relationship('User')

    notifications_to_users = relationship('UserNotification', lazy='joined',

                                          cascade="all, delete, delete-orphan")

    @property

    def recipients(self):

        return [x.user for x in UserNotification.query()\

                .filter(UserNotification.notification == self).all()]

    @classmethod

    def create(cls, created_by, subject, body, recipients, type_=None):

        if type_ is None:

            type_ = Notification.TYPE_MESSAGE

        notification = cls()

        notification.created_by_user = created_by

        notification.subject = subject

        notification.body = body

        notification.type_ = type_

        notification.created_on = datetime.datetime.now()

        for u in recipients:

            assoc = UserNotification()

            assoc.notification = notification

            u.notifications.append(assoc)

        Session.add(notification)

        return notification

    @property

    def description(self):

        from rhodecode.model.notification import NotificationModel

        return NotificationModel().make_description(self)

class UserNotification(Base, BaseModel):

    __tablename__ = 'user_to_notification'

    __table_args__ = (

        UniqueConstraint('user_id', 'notification_id'),

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'}

    )

    user_id = Column('user_id', Integer(), ForeignKey('users.user_id'), primary_key=True)

    notification_id = Column("notification_id", Integer(), ForeignKey('notifications.notification_id'), primary_key=True)

    read = Column('read', Boolean, default=False)

    sent_on = Column('sent_on', DateTime(timezone=False), nullable=True, unique=None)

    user = relationship('User', lazy="joined")

    notification = relationship('Notification', lazy="joined",

                                order_by=lambda: Notification.created_on.desc(),)

    def mark_as_read(self):

        self.read = True

        Session.add(self)

class DbMigrateVersion(Base, BaseModel):

    __tablename__ = 'db_migrate_version'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine':'InnoDB',

         'mysql_charset': 'utf8'},

    )

    repository_id = Column('repository_id', String(250), primary_key=True)

    repository_path = Column('repository_path', Text)

    version = Column('version', Integer)

## this is migration from 1_4_0, but now it's here to overcome a problem of

## attaching a FK to this from 1_3_0 !

class PullRequest(Base, BaseModel):

    __tablename__ = 'pull_requests'

    __table_args__ = (

        {'extend_existing': True, 'mysql_engine': 'InnoDB',

         'mysql_charset': 'utf8'},

    )

    STATUS_NEW = u'new'

    STATUS_OPEN = u'open'

    STATUS_CLOSED = u'closed'

    pull_request_id = Column('pull_request_id', Integer(), nullable=False, primary_key=True)

    title = Column('title', Unicode(256), nullable=True)

    description = Column('description', UnicodeText(10240), nullable=True)

    status = Column('status', Unicode(256), nullable=False, default=STATUS_NEW)

    created_on = Column('created_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    updated_on = Column('updated_on', DateTime(timezone=False), nullable=False, default=datetime.datetime.now)

    user_id = Column("user_id", Integer(), ForeignKey('users.user_id'), nullable=False, unique=None)

    _revisions = Column('revisions', UnicodeText(20500))  # 500 revisions max

    org_repo_id = Column('org_repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

    org_ref = Column('org_ref', Unicode(256), nullable=False)

    other_repo_id = Column('other_repo_id', Integer(), ForeignKey('repositories.repo_id'), nullable=False)

"""

Mercurial libs compatibility

"""

from mercurial import archival, merge as hg_merge, patch, ui

from mercurial.commands import clone, nullid, pull

from mercurial.context import memctx, memfilectx

from mercurial.error import RepoError, RepoLookupError, Abort

from mercurial.hgweb.common import get_contact

from mercurial.localrepo import localrepository

from mercurial.match import match

from mercurial.mdiff import diffopts

from mercurial.node import hex

from mercurial.encoding import tolocal

from mercurial import discovery

from mercurial import localrepo

from mercurial import scmutil

""" this is forms validation classes

http://formencode.org/module-formencode.validators.html

for list off all availible validators

we can create our own validators

The table below outlines the options which can be used in a schema in addition to the validators themselves

pre_validators          []     These validators will be applied before the schema

chained_validators      []     These validators will be applied after the schema

allow_extra_fields      False     If True, then it is not an error when keys that aren't associated with a validator are present

filter_extra_fields     False     If True, then keys that aren't associated with a validator are removed

if_key_missing          NoDefault If this is given, then any keys that aren't available but are expected will be replaced with this value (and then validated). This does not override a present .if_missing attribute on validators. NoDefault is a special FormEncode class to mean that no default values has been specified and therefore missing keys shouldn't take a default value.

ignore_key_missing      False     If True, then missing keys will be missing in the result, if the validator doesn't have .if_missing on it already

<name> = formencode.validators.<name of validator>

<name> must equal form name

list=[1,2,3,4,5]

for SELECT use formencode.All(OneOf(list), Int())

"""

import logging

import formencode

from formencode import All

from pylons.i18n.translation import _

from rhodecode.model import validators as v

from rhodecode import BACKENDS

log = logging.getLogger(__name__)

class LoginForm(formencode.Schema):

    allow_extra_fields = True

    filter_extra_fields = True

    username = v.UnicodeString(

        strip=True,

        min=1,

        not_empty=True,

        messages={

           'empty': _(u'Please enter a login'),

           'tooShort': _(u'Enter a value %(min)i characters long or more')}

    )

    password = v.UnicodeString(

        strip=False,

        min=3,

        not_empty=True,

        messages={

            'empty': _(u'Please enter a password'),

            'tooShort': _(u'Enter %(min)i characters or more')}

    )

    remember = v.StringBoolean(if_missing=False)

    chained_validators = [v.ValidAuth()]

def UserForm(edit=False, old_data={}):

    class _UserForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        username = All(v.UnicodeString(strip=True, min=1, not_empty=True),

                       v.ValidUsername(edit, old_data))

        if edit:

            new_password = All(

                v.ValidPassword(),

                v.UnicodeString(strip=False, min=6, not_empty=False)

            )