def settings(self):

        return []

    def user_activation_state(self):

        def_user_perms = User.get_default_user().AuthUser.permissions['global']

        return 'hg.register.auto_activate' in def_user_perms

    def accepts(self, user, accepts_empty=True):

        """

        Custom accepts for this auth that doesn't accept empty users. We

        know that user exists in database.

        """

        return super(KallitheaAuthPlugin, self).accepts(user,

                                                        accepts_empty=False)

    def auth(self, userobj, username, password, settings, **kwargs):

        if not userobj:

            log.debug('userobj was:%s skipping', userobj)

            return None

        if userobj.extern_type != self.name:

            log.warning("userobj:%s extern_type mismatch got:`%s` expected:`%s`",

                     userobj, userobj.extern_type, self.name)

            return None

        user_data = {

            "username": userobj.username,

            "firstname": userobj.firstname,

            "lastname": userobj.lastname,

            "groups": [],

            "email": userobj.email,

            "admin": userobj.admin,

            "active": userobj.active,

            "active_from_extern": userobj.active,

            "extern_name": userobj.user_id,

        }

        log.debug(formatted_json(user_data))

        if userobj.active:

            from kallithea.lib import auth

            password_match = auth.KallitheaCrypto.hash_check(password, userobj.password)

            if userobj.username == User.DEFAULT_USER and userobj.active:

                log.info('user %s authenticated correctly as anonymous user',

                         username)

                return user_data

            elif userobj.username == username and password_match:

                log.info('user %s authenticated correctly', user_data['username'])

            {

                "name": "service",

                "validator": self.validators.UnicodeString(strip=True),

                "type": "string",

                "description": "PAM service name to use for authentication",

                "default": "login",

                "formname": "PAM service name"

            },

            {

                "name": "gecos",

                "validator": self.validators.UnicodeString(strip=True),

                "type": "string",

                "description": "Regex for extracting user name/email etc "

                               "from Unix userinfo",

                "default": "(?P<last_name>.+),\s*(?P<first_name>\w+)",

                "formname": "Gecos Regex"

            }

        ]

        return settings

    def use_fake_password(self):

        return True

    def auth(self, userobj, username, password, settings, **kwargs):

        if username not in _auth_cache:

            # Need lock here, as PAM authentication is not thread safe

            _pam_lock.acquire()

            try:

                auth_result = pam.authenticate(username, password,

                                               settings["service"])

                # cache result only if we properly authenticated

                if auth_result:

                    _auth_cache[username] = time.time()

            finally:

                _pam_lock.release()

            if not auth_result:

                log.error("PAM was unable to authenticate user: %s", username)

                return None

        else:

            log.debug("Using cached auth for user: %s", username)

        # old attrs fetched from Kallithea database

        admin = getattr(userobj, 'admin', False)

        active = getattr(userobj, 'active', True)

        email = getattr(userobj, 'email', '') or "%s@%s" % (username, socket.gethostname())

        firstname = getattr(userobj, 'firstname', '')

        lastname = getattr(userobj, 'lastname', '')

class LimitedDiffContainer(object):

    def __init__(self, diff_limit, cur_diff_size, diff):

        self.diff = diff

        self.diff_limit = diff_limit

        self.cur_diff_size = cur_diff_size

    def __iter__(self):

        for l in self.diff:

            yield l

class DiffProcessor(object):

    """

    Give it a unified or git diff and it returns a list of the files that were

    mentioned in the diff together with a dict of meta information that

    can be used to render it in a HTML template.

    """

    _chunk_re = re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)')

    _newline_marker = re.compile(r'^\\ No newline at end of file')

    _git_header_re = re.compile(r"""

        # has already been split on this:

        # ^diff[ ]--git

            [ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

        (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%\n

           ^rename[ ]from[ ](?P<rename_from>.+)\n

           ^rename[ ]to[ ](?P<rename_to>.+)(?:\n|$))?

        (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?

        (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?

        (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)

            \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?

        (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?

        (?:^---[ ](a/(?P<a_file>.+?)|/dev/null)\t?(?:\n|$))?

        (?:^\+\+\+[ ](b/(?P<b_file>.+?)|/dev/null)\t?(?:\n|$))?

    """, re.VERBOSE | re.MULTILINE)

    _hg_header_re = re.compile(r"""

        # has already been split on this:

        # ^diff[ ]--git

            [ ]a/(?P<a_path>.+?)[ ]b/(?P<b_path>.+?)\n

        (?:^old[ ]mode[ ](?P<old_mode>\d+)\n

           ^new[ ]mode[ ](?P<new_mode>\d+)(?:\n|$))?

        (?:^similarity[ ]index[ ](?P<similarity_index>\d+)%(?:\n|$))?

        (?:^rename[ ]from[ ](?P<rename_from>.+)\n

           ^rename[ ]to[ ](?P<rename_to>.+)(?:\n|$))?

        (?:^copy[ ]from[ ](?P<copy_from>.+)\n

           ^copy[ ]to[ ](?P<copy_to>.+)(?:\n|$))?

        (?:^new[ ]file[ ]mode[ ](?P<new_file_mode>.+)(?:\n|$))?

        (?:^deleted[ ]file[ ]mode[ ](?P<deleted_file_mode>.+)(?:\n|$))?

        (?:^index[ ](?P<a_blob_id>[0-9A-Fa-f]+)

            \.\.(?P<b_blob_id>[0-9A-Fa-f]+)[ ]?(?P<b_mode>.+)?(?:\n|$))?

        (?:^(?P<bin_patch>GIT[ ]binary[ ]patch)(?:\n|$))?

        path = safe_str(path)

        repo_path = safe_str(repo.path)

        assert path.startswith(repo_path)

        assert path[len(repo_path)] in (os.path.sep, os.path.altsep)

        node_path = path[len(repo_path) + 1:]

        cs = self._get_index_changeset(repo, index_rev=index_rev)

        node = cs.get_node(node_path)

        return node

    def is_indexable_node(self, node):

        """

        Just index the content of chosen files, skipping binary files

        """

        return (node.extension in INDEX_EXTENSIONS or node.name in INDEX_FILENAMES) and \

               not node.is_binary

    def get_node_mtime(self, node):

        return mktime(node.last_changeset.date.timetuple())

    def add_doc(self, writer, path, repo, repo_name, index_rev=None):

        """

        Adding doc to writer this function itself fetches data from

        the instance of vcs backend

        """

        indexed = indexed_w_content = 0

        if self.is_indexable_node(node):

            u_content = node.content

            if not isinstance(u_content, unicode):

                log.warning('  >> %s Could not get this content as unicode '

                            'replacing with empty content' % path)

                u_content = u''

            else:

                log.debug('    >> %s [WITH CONTENT]', path)

                indexed_w_content += 1

        else:

            log.debug('    >> %s', path)

            # just index file name without it's content

            u_content = u''

            indexed += 1

        p = safe_unicode(path)

        writer.add_document(

            fileid=p,

            owner=unicode(repo.contact),

            repository=safe_unicode(repo_name),

            path=p,

            content=u_content,

            Session().delete(inv_obj)

        Session().commit()

    @classmethod

    def test_and_set_valid(cls, repo_name, kind, valid_cache_keys=None):

        """

        Mark this cache key as active and currently cached.

        Return True if the existing cache registration still was valid.

        Return False to indicate that it had been invalidated and caches should be refreshed.

        """

        key = (repo_name + '_' + kind) if kind else repo_name

        cache_key = cls._get_cache_key(key)

        if valid_cache_keys and cache_key in valid_cache_keys:

            return True

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

        if not inv_obj:

            inv_obj = CacheInvalidation(cache_key, repo_name)

        if inv_obj.cache_active:

            return True

        inv_obj.cache_active = True

        Session().add(inv_obj)

        Session().commit()

        return False

    @classmethod

    def get_valid_cache_keys(cls):

        """

        Return opaque object with information of which caches still are valid

        and can be used without checking for invalidation.

        """

        return set(inv_obj.cache_key for inv_obj in cls.query().filter(cls.cache_active).all())

class ChangesetComment(Base, BaseModel):

    __tablename__ = 'changeset_comments'

    __table_args__ = (

        Index('cc_revision_idx', 'revision'),

        Index('cc_pull_request_id_idx', 'pull_request_id'),

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

         'mysql_charset': 'utf8', 'sqlite_autoincrement': True},

    )

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

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

    revision = Column(String(40))

    pull_request_id = Column(Integer(), ForeignKey('pull_requests.pull_request_id'))

    line_no = Column(Unicode(10))

                return -1;

            }

            if (bPos === 0 && aPos !== 0) {

                return 1;

            }

            // Default sorting

            if (a.text > b.text) {

                return 1;

            }

            if (a.text < b.text) {

                return -1;

            }

            return 0;

        });

    }

    return results;

};

// global hooks after DOM is loaded

$(document).ready(function(){

    $('.diff-collapse-button').click(function(e) {

        var $button = $(e.currentTarget);

        if($target.hasClass('hidden')){

            $target.removeClass('hidden');

            $button.html("↑ {0} ↑".format(_TM['Collapse Diff']));

        }

        else if(!$target.hasClass('hidden')){

            $target.addClass('hidden');

            $button.html("↓ {0} ↓".format(_TM['Expand Diff']));

        }

    });

});

diff --git a/work-horus.xls b/file.xls

similarity index 100%

rename from work-horus.xls

rename to file.xls

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('less/scaffolding.less', 'M',

         {'added': 1,

          'deleted': 3,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

        ('readme.markdown', 'M',

         {'added': 1,

          'deleted': 10,

          'binary': False,

          'ops': {MOD_FILENODE: 'modified file'}}),

    ],

    'git_diff_chmod.diff': [

        ('work-horus.xls', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {CHMOD_FILENODE: 'modified file chmod 100644 => 100755'}})

    ],

    'git_diff_rename_file.diff': [

        ('file.xls', 'R',

         {'added': 0,

          'deleted': 0,

          'binary': True,

    ],

    'git_diff_mod_single_binary_file.diff': [

        ('US Warszawa.jpg', 'M',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {MOD_FILENODE: 'modified file',

                  BIN_FILENODE: 'binary diff not shown'}})

    ],

    'git_diff_binary_and_normal.diff': [

        ('img/baseline-10px.png', 'A',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {NEW_FILENODE: 'new file 100644',

                  BIN_FILENODE: 'binary diff not shown'}}),

        ('img/baseline-20px.png', 'D',

         {'added': 0,

          'deleted': 0,

          'binary': True,

          'ops': {DEL_FILENODE: 'deleted file',

                  BIN_FILENODE: 'binary diff not shown'}}),

        ('index.html', 'M',

         {'added': 3,