self.items = []

        # This is a subclass of the 'list' type. Initialise the list now.

        list.__init__(self, reversed(self.items))

def changed_tooltip(nodes):

    """

    Generates a html string for changed nodes in changeset page.

    It limits the output to 30 entries

    :param nodes: LazyNodesGenerator

    """

    if nodes:

        pref = ': <br/> '

        suf = ''

        if len(nodes) > 30:

            suf = '<br/>' + _(' and %s more') % (len(nodes) - 30)

        return literal(pref + '<br/> '.join([safe_unicode(x.path)

                                             for x in nodes[:30]]) + suf)

    else:

        return ': ' + _('No Files')

    """

    Makes a breadcrumbs link to repo within a group

    joins » on each group to create a fancy link

    ex::

        group >> subgroup >> repo

    :param groups_and_repos:

    :param last_url:

    """

        def make_link(group):

            return link_to(group.name,

                           url('repos_group_home', group_name=group.group_name))

def fancy_file_stats(stats):

    """

    Displays a fancy two colored bar for number of added/deleted

    lines of code on file

    :param stats: two element list of added/deleted lines of code

    """

    def cgen(l_type, a_v, d_v):

        mapping = {'tr': 'top-right-rounded-corner-mid',

                   'tl': 'top-left-rounded-corner-mid',

                   'br': 'bottom-right-rounded-corner-mid',

                   'bl': 'bottom-left-rounded-corner-mid'}

        map_getter = lambda x: mapping[x]

        if l_type == 'a' and d_v:

            #case when added and deleted are present

            return ' '.join(map(map_getter, ['tl', 'bl']))

        if l_type == 'a' and not d_v:

            return ' '.join(map(map_getter, ['tr', 'br', 'tl', 'bl']))

        if l_type == 'd' and a_v:

    @property

    def just_name(self):

        return self.repo_name.split(Repository.url_sep())[-1]

    @property

    def groups_with_parents(self):

        groups = []

        if self.group is None:

            return groups

        cur_gr = self.group

        groups.insert(0, cur_gr)

        while 1:

            gr = getattr(cur_gr, 'parent_group', None)

            cur_gr = cur_gr.parent_group

            if gr is None:

                break

            groups.insert(0, gr)

        return groups

    @property

    def groups_and_repo(self):

    @LazyProperty

    def repo_path(self):

        """

        Returns base full path for that repository means where it actually

        exists on a filesystem

        """

        q = Session().query(RhodeCodeUi).filter(RhodeCodeUi.ui_key ==

                                              Repository.url_sep())

        q = q.options(FromCache("sql_cache_short", "repository_repo_path"))

        return q.one().ui_value

    @property

    def repo_full_path(self):

        p = [self.repo_path]

        # we need to split the name by / since this is how we store the

        # names in the database, but that eventually needs to be converted

        # into a valid system path

        p += self.repo_name.split(Repository.url_sep())

        return os.path.join(*p)

    @property

    def cache_keys(self):

        """

            repos_data.append(row)

        return {

            "totalRecords": len(repos_list),

            "startIndex": 0,

            "sort": "name",

            "dir": "asc",

            "records": repos_data

        }

    def _get_defaults(self, repo_name):

        """

        Get's information about repository, and returns a dict for

        usage in forms

        :param repo_name:

        """

        repo_info = Repository.get_by_repo_name(repo_name)

        if repo_info is None:

            return None

        defaults = repo_info.get_dict()

        defaults['repo_name'] = repo_name

        defaults['repo_group'] = getattr(group[-1] if group else None,

                                         'group_id', None)

        for strip, k in [(0, 'repo_type'), (1, 'repo_enable_downloads'),

                  (1, 'repo_description'), (1, 'repo_enable_locking'),

                  (1, 'repo_landing_rev'), (0, 'clone_uri'),

                  (1, 'repo_private'), (1, 'repo_enable_statistics')]:

            attr = k

            if strip:

                attr = remove_prefix(k, 'repo_')

            defaults[k] = defaults[attr]

        # fill owner

        if repo_info.user:

            defaults.update({'user': repo_info.user.username})

        else:

            replacement_user = User.query().filter(User.admin ==

                                                   True).first().username

            defaults.update({'user': replacement_user})

        # fill repository users

        for p in repo_info.repo_to_perm:

  <ul>

      <li>${h.link_to(_('repository groups'),h.url('repos_groups'),class_='repos_groups')}</li>

  </ul>

</%def>

<%def name="repo_context_bar(current=None)">

  <%

      def follow_class():

          if c.repository_following:

              return h.literal('following')

          else:

            return h.literal('follow')

  %>

  <%

    def is_current(selected):

        if selected == current:

            return h.literal('class="current"')

    %>

  <!--- CONTEXT BAR -->

  <div id="context-bar" class="box">

    <div id="context-top">

      <div id="breadcrumbs">

        ${h.link_to(_(u'Repositories'),h.url('home'))}

        ${h.repo_link(c.rhodecode_db_repo.groups_and_repo)}

      </div>

      ## TODO: this check feels wrong, it would be better to have a check for permissions

      ## also it feels like a job for the controller

      %if c.rhodecode_user.username != 'default':

        <ul id="context-actions" class="horizontal-list">

          <li>

           <button class="${follow_class()}" onclick="javascript:toggleFollowingRepo(this,${c.rhodecode_db_repo.repo_id},'${str(h.get_token())}');">

            <!--span class="icon show-follow follow"></span>

            <span class="icon show-following following"></span-->

            <span class="show-follow">${_('Follow')}</span>

            <span class="show-following">${_('Unfollow')}</span>

          </button>

          </li>

          <li><a href="${h.url('repo_fork_home',repo_name=c.repo_name)}" class="fork">${_('Fork')}</a></li>

          %if h.is_hg(c.rhodecode_repo):

          <li><a href="${h.url('pullrequest_home',repo_name=c.repo_name)}" class="pull-request">${_('Create Pull Request')}</a></li>

          %endif

        </ul>

      %endif

    </div>

    <div id="context-state">

      <ul id="context-pages" class="horizontal-list">

        <li ${is_current('summary')}><a href="${h.url('summary_home', repo_name=c.repo_name)}" class="summary">${_('Summary')}</a></li>