# extensions will index it's content

LANGUAGES_EXTENSIONS_MAP = pygmentsutils.get_extension_descriptions()

# Whoosh index targets

# Extensions we want to index content of using whoosh

# Filenames we want to index content of using whoosh

INDEX_FILENAMES = pygmentsutils.get_index_filenames()

# list of readme files to search in file tree and display in summary

# attached weights defines the search  order lower is first

            if c.file.is_submodule():

                raise HTTPFound(location=c.file.url)

            elif c.file.is_file():

                c.load_full_history = False

                # determine if we're on branch head

                _branches = c.db_repo_scm_instance.branches

                _hist = []

                c.file_history = []

                if c.load_full_history:

                    c.file_history, _hist = self._get_node_history(c.changeset, f_path)

                c.authors = []

    def delete(self, repo_name, revision, f_path):

        repo = c.db_repo

        # check if revision is a branch identifier- basically we cannot

        # create multiple heads via file editing

        _branches = repo.scm_instance.branches

        # check if revision is a branch name or branch hash

            h.flash(_('You can only delete files with revision '

                      'being a valid branch'), category='warning')

            raise HTTPFound(location=h.url('files_home',

                                  repo_name=repo_name, revision='tip',

                                  f_path=f_path))

    def edit(self, repo_name, revision, f_path):

        repo = c.db_repo

        # check if revision is a branch identifier- basically we cannot

        # create multiple heads via file editing

        _branches = repo.scm_instance.branches

        # check if revision is a branch name or branch hash

            h.flash(_('You can only edit files with revision '

                      'being a valid branch'), category='warning')

            raise HTTPFound(location=h.url('files_home',

                                  repo_name=repo_name, revision='tip',

                                  f_path=f_path))

                    selected = 'tag:null:' + repo.EMPTY_CHANGESET

                    tags.append((selected, 'null'))

            else:

                if 'master' in repo.branches:

                    selected = 'branch:master:%s' % repo.branches['master']

                else:

                    selected = 'branch:%s:%s' % (k, v)

        groups = [(specials, _("Special")),

                  (peers, _("Peer branches")),

                  (bookmarks, _("Bookmarks")),

                  (branches, _("Branches")),

        c.instance_id = config.get('instance_id')

        c.issues_url = config.get('bugtracker', url('issues_url'))

        # END CONFIG VARS

        c.repo_name = get_repo_slug(request)  # can be empty

        self.cut_off_limit = safe_int(config.get('cut_off_limit'))

        c.my_pr_count = PullRequest.query(reviewer_id=request.authuser.user_id, include_closed=False).count()

        self.scm_model = ScmModel()

    tip = repo.get_changeset()

    code_stats = {}

    for _topnode, _dirnodes, filenodes in tip.walk('/'):

        for filenode in filenodes:

            ext = filenode.extension.lower()

                if ext in code_stats:

                    code_stats[ext] += 1

                else:

                    code_stats[ext] = 1

    return code_stats or {}

        assert CONFIG['sqlalchemy.url'] # make sure config has been loaded

        # Build chain of urlify functions, starting with not doing any transformation

        tmp_urlify_issues_f = lambda s: s

        issue_pat_re = re.compile(r'issue_pat(.*)')

            # Find all issue_pat* settings that also have corresponding server_link and prefix configuration

            m = issue_pat_re.match(k)

            if m is None:

                continue

            suffix = m.group(1)

            issue_pat = CONFIG.get(k)

            (``repo-tip.<KIND>``).

        :param subrepos: include subrepos in this archive.

        :raise ImproperArchiveTypeError: If given kind is wrong.

        :raise VcsError: If given stream is None

        """

        if kind not in allowed_kinds:

            raise ImproperArchiveTypeError('Archive kind not supported use one'

        if stream is None:

            raise VCSError('You need to pass in a valid stream for filling'

                           ' with archival data')

        if prefix is None:

            (``repo-tip.<KIND>``).

        :param subrepos: include subrepos in this archive.

        :raise ImproperArchiveTypeError: If given kind is wrong.

        :raise VcsError: If given stream is None

        """

        if kind not in allowed_kinds:

            raise ImproperArchiveTypeError('Archive kind not supported use one'

        if stream is None:

            raise VCSError('You need to pass in a valid stream for filling'

                           ' with archival data')

        if prefix is None:

        return self._get_tags()

    def _get_tags(self):

        if self._empty:

            return {}

    def tag(self, name, user, revision=None, message=None, date=None,

            **kwargs):

        """

        Creates and returns a tag for the given ``revision``.

        return self._get_bookmarks()

    def _get_bookmarks(self):

        if self._empty:

            return {}

    def _get_all_revisions(self):

        return [self._repo[x].hex() for x in self._repo.filtered('visible').changelog.revs()]

    def get_diff(self, rev1, rev2, path='', ignore_whitespace=False,

        end_pos = self.revisions.index(end_raw_id) if end else None

        if None not in [start, end] and start_pos > end_pos:

            raise RepositoryError("Start revision '%s' cannot be "

                                  "after end revision '%s'" % (start, end))

            msg = ("Branch %s not found in %s" % (branch_name, self))

            raise BranchDoesNotExistError(msg)

        if end_pos is not None:

            end_pos += 1

        # filter branches

        filter_ = []

        return self._app_settings_type

    @app_settings_type.setter

    def app_settings_type(self, val):

        if val not in self.SETTINGS_TYPES:

            raise Exception('type must be one of %s got %s'

        self._app_settings_type = val

    def __unicode__(self):

        return u"<%s('%s:%s[%s]')>" % (

            self.__class__.__name__,

            self.app_settings_name, self.app_settings_value, self.app_settings_type

        chained_validators = [v.ValidPasswordsMatch('password',

                                                    'password_confirm')]

    return _PasswordResetConfirmationForm

             repo_groups=None, landing_revs=None):

    old_data = old_data or {}

    repo_groups = repo_groups or []

    landing_revs = landing_revs or []

    repo_group_ids = [rg[0] for rg in repo_groups]

        new_field_label = v.UnicodeString(not_empty=False)

        new_field_desc = v.UnicodeString(not_empty=False)

    return _RepoFieldForm

                 repo_groups=None, landing_revs=None):

    old_data = old_data or {}

    repo_groups = repo_groups or []

    landing_revs = landing_revs or []

    repo_group_ids = [rg[0] for rg in repo_groups]

        fork_repo_perm = v.StringBoolean(if_missing=False)

    return _CustomDefaultPermissionsForm

    class _DefaultsForm(formencode.Schema):

        allow_extra_fields = True

        filter_extra_fields = True

        default_repo_type = v.OneOf(supported_backends)

        default_repo_private = v.StringBoolean(if_missing=False)

        default_repo_enable_statistics = v.StringBoolean(if_missing=False)

                    raise RepositoryError('Duplicate repository name %s '

                                          'found in %s' % (name, path))

                else:

                    klass = get_backend(path[0])

                        repos[name] = klass(safe_str(path[1]), baseui=baseui)

                        repos[name] = klass(path[1])

            except OSError:

                continue

        log.debug('found %s paths with repositories', len(repos))

        return repos

                        new_perms_group[args[0]]['perm'] = v

                    elif len(args) == 2:

                        _key, pos = args

                        new_perms_group[pos][_key] = v

            # fill new permissions in order of how they were added

                new_member = perm_dict.get('name')

                new_perm = perm_dict.get('perm')

                new_type = perm_dict.get('type')

                if new_member and new_perm and new_type:

                    perms_new.add((new_member, new_perm, new_type))

            branch='foobar',

        )

        assert 'foobar' in self.repo.branches

        assert foobar_tip.branch == 'foobar'

        assert foobar_tip.branches == ['foobar']

        # 'foobar' should be the only branch that contains the new commit

        assert branch_tips.count(str(foobar_tip.raw_id)) == 1

    def test_new_head_in_default_branch(self):

        tip = self.repo.get_changeset()

        self.imc.add(vcs.nodes.FileNode('docs/index.txt',

            content='Documentation\n'))