def render_timeline_event(self, context, field, event):
     bp_resource, bp, bc = event[3]
     compat_format_0_11_2 = 'oneliner'
     if hasattr(context, '_hints'):
          compat_format_0_11_2 = None
     if bc: # A blog comment
         if field == 'url':
             return context.href.blog(bp.name) + '#comment-%d' % bc.number
         elif field == 'title':
             return tag('Blog: ', tag.em(bp.title), ' comment added')
         elif field == 'description':
             comment = compat_format_0_11_2 and shorten_line(bc.comment) \
                         or bc.comment
             return format_to(self.env, compat_format_0_11_2,
                         context(resource=bp_resource), comment)
     else: # A blog post
         if field == 'url':
             return context.href.blog(bp.name)
         elif field == 'title':
             return tag('Blog: ', tag.em(bp.title),
                     bp.version > 1 and ' edited' or ' created')
         elif field == 'description':
             comment = compat_format_0_11_2 and shorten_line(bp.version_comment) \
                         or bp.version_comment
             return format_to(self.env, compat_format_0_11_2,
                     context(resource=bp_resource), comment)

 def short_value(self):
     if self.is_scalar:
         if isinstance(self.value, basestring):
             value = self.value
             if not isinstance(self.value, unicode):
                 value = unicode(self.value, 'utf-8', 'replace')
             return tag.q(shorten_line(value, 60)).generate()
         else:
             return shorten_line(repr(self.value), 60)
     elif self.is_collection:
         if isinstance(self.value, (dict, DictMixin)):
             return u'{…}'
         elif isinstance(self.value, list):
             return u'[…]'
         elif isinstance(self.value, tuple):
             return u'(…)'
         elif isinstance(self.value, set):
             return u'set([…])'
         elif isinstance(self.value, frozenset):
             return u'frozenset([…])'
     else:
         try:
             return tag.code(shorten_line(str(self.value), 60))
         except:
             return '?'

def _ticket_links(env, formatter, t, a_class=""):
    """Build links to tickets."""
    tkt_id = str(t.get("id"))
    status = t.get("status")
    summary = to_unicode(t.get("summary"))
    owner = to_unicode(t.get("owner"))
    description = to_unicode(t.get("description"))
    url = t.get("href")

    if status == "closed":
        a_class = a_class + "closed"
    else:
        a_class = a_class + "open"

    # Reduce content for tooltips.
    markup = format_to_html(env, formatter.context, description)
    extractor = TextExtractor()
    extractor.feed(markup)
    tip = tag.span(shorten_line(extractor.getvalue()))

    ticket = tag.a("#" + tkt_id, href=url)
    ticket(tip, class_="tip", target="_blank")
    ticket = tag.div(ticket, class_=a_class, align="left")
    # Fix stripping of regular leading space in IE.
    blank = " "
    ticket(Markup(blank), summary, " (", owner, ")")

    summary = tag(summary, " (", owner, ")")
    ticket_short = tag.span(tag.a("#" + tkt_id, href=url, target="_blank", title_=summary), class_=a_class)
    return ticket, ticket_short

 def render_timeline_event(self, context, field, event):
     ticket,summary,status,resolution,type, started, comment = event[4]
     if field == 'url':
         return context.href.ticket(ticket.id)
     elif field == 'title':
         title = TicketSystem(self.env).format_summary(summary, status,
                                                       resolution, type)
         return tag('Work ', started and 'stopped' or 'started',
                    ' on Ticket ', tag.em('#', ticket.id, title=title),
                    ' (', shorten_line(summary), ') ')
     elif field == 'description':
         if self.config['timeline'].getbool('abbreviated_messages'):
             comment = shorten_line(comment)
         markup = format_to_oneliner(self.env, context(resource=ticket),
                                     comment)
         return markup

 def get_search_results(self, req, terms, filters):
     """
     Search through requirements.
     
     The search term may be <x y z> or x-y-z; both are interpreted as
     component, fp, and object.
     """
     
     if not 'requirement' in filters:
         return
     
     if re.match(r'^([a-zA-Z_\d]+)-([a-zA-Z_\d]+)-([a-zA-Z_\d]+)$', terms[0]):
         terms = string.split(terms[0], '-')
         
     db = self.env.get_db_cnx()
     sql, args = search_to_sql(db, ['b.newvalue'], terms)
     sql2, args2 = search_to_sql(db, ['a.component', 'a.fp', 'a.object',
                                      'a.description', 'a.creator'], terms)
     
     cursor = db.cursor()
     cursor.execute("SELECT DISTINCT a.component, a.fp, a.object, "
                    "a.description, a.creator, a.time "
                    "FROM requirement a "
                    "LEFT JOIN requirement_change b "
                    "ON a.component = b.component AND a.fp = b.fp AND a.object = b.object "
                    "WHERE (b.field='comment' AND %s ) OR %s" % (sql, sql2),
                    args + args2)
     
     for component, fp, object, desc, creator, date in cursor:
         requirement = '<%s %s %s> ' % (component, fp, object)
         yield (req.href.requirement('%s-%s-%s' % (component, fp, object)),
                requirement + shorten_line(desc),
                date, creator, shorten_result(desc, terms))

 def _link_refs(self, req, refs_text, verbose_link=False):
     items_tag = None
     items, verbose_items = [], []
     elem = verbose_elem = "#%s" % refs_text
     try:
         c = self.cursor
         c.execute("SELECT id,name FROM assets_feature WHERE id ='%s'" % refs_text)
         row = c.fetchone()
         if row:
             title = shorten_line(row[1])
             attr = {
                 "class_": "assigned",
                 "href": "/splice/tractab/SPLICE/projects/feature/" + str(row[0]),
                 "title": title,
             }
             elem = tag.a("#%s %s" % (refs_text, title), **attr)
             verbose_elem = tag.a("#%s %s" % (refs_text, title), **attr)
     except ResourceNotFound:
         pass  # not supposed to happen, just in case
     items.extend([elem, ", "])
     verbose_items.extend([verbose_elem, tag.br()])
     if items:
         items_tag = [tag.span(items[:-1], id="tref_ticketid")]
         if verbose_link:
             vattr = {"id": "tref_summary", "class_": "tref-display-none"}
             items_tag.append(tag.span(verbose_items[:-1], **vattr))
     return tag(items_tag)

    def get_search_results(self, req, terms, filters):
        if not 'wiki' in filters:
            return
        db = self.env.get_db_cnx()
        sql_query, args = search_to_sql(db, ['w1.name', 'w1.author', 'w1.text'],
                                        terms)
        cursor = db.cursor()
        cursor.execute("SELECT w1.name,w1.time,w1.author,w1.text "
                       "FROM wiki w1,"
                       "(SELECT name,max(version) AS ver "
                       "FROM wiki GROUP BY name) w2 "
                       "WHERE w1.version = w2.ver AND w1.name = w2.name "
                       "AND " + sql_query, args)

        wiki_realm = Resource('wiki')
        for name, ts, author, text in cursor:
            page = wiki_realm(id=name)
            if 'WIKI_VIEW' in req.perm(page):
                yield (get_resource_url(self.env, page, req.href),
                       '%s: %s' % (name, shorten_line(text)),
                       datetime.fromtimestamp(ts, utc), author,
                       shorten_result(text, terms))
        
        # Attachments
        for result in AttachmentModule(self.env).get_search_results(
            req, wiki_realm, terms):
            yield result

    def train(self, req, log_id, spam=True):
        environ = {}
        for name, value in req.environ.items():
            if not name.startswith('HTTP_'):
                environ[name] = value

        entry = LogEntry.fetch(self.env, log_id)
        if entry:
            self.log.debug('Marking as %s: %r submitted by "%s"',
                           spam and 'spam' or 'ham',
                           shorten_line(entry.content),
                           entry.author)
            fakeenv = environ.copy()
            for header in entry.headers.splitlines():
                name, value = header.split(':', 1)
                if name == 'Cookie': # breaks SimpleCookie somehow
                    continue
                cgi_name = 'HTTP_%s' % name.strip().replace('-', '_').upper()
                fakeenv[cgi_name] = value.strip()
            fakeenv['REQUEST_METHOD'] = 'POST'
            fakeenv['PATH_INFO'] = entry.path
            fakeenv['wsgi.input'] = StringIO('')
            fakeenv['REMOTE_ADDR'] = entry.ipnr
            if entry.authenticated:
                fakeenv['REMOTE_USER'] = entry.author

            for strategy in self.strategies:
                strategy.train(Request(fakeenv, None),
                               entry.author or 'anonymous',
                               entry.content, spam=spam)

            entry.update(rejected=spam)

    def changeset_added(self, repos, changeset):
        """Called after a changeset has been added to a repository."""
        #Index the commit message
        so = FullTextSearchObject(
                self.project, changeset.resource,
                title=u'[%s]: %s' % (changeset.rev,
                                       shorten_line(changeset.message)),
                oneline=shorten_result(changeset.message),
                body=changeset.message,
                author=changeset.author,
                created=changeset.date,
                changed=changeset.date,
                )
        self.backend.create(so, quiet=True)
        self._update_changeset(changeset)

        # Index the file contents of this revision, a changeset can involve
        # thousands of files - so submit in batches to avoid exceeding the
        # available file handles
        sos = (so for so in self._changes(repos, changeset))
        for chunk in grouper(sos, 25):
            try:
                self.backend.add(chunk, quiet=True)
                self.log.debug("Indexed %i repository changes at revision %i",
                               len(chunk), changeset.rev)
            finally:
                for so in chunk:
                    if hasattr(so.body, 'close'):
                        so.body.close()

    def _link_tickets(self, req, tickets, fetch_tickets=False):
        items = []

        for i, word in enumerate(re.split(r'([;,\s]+)', tickets or '')):
            if i % 2:
                items.append(word)
            elif word:
                try:
                    ticketid = int(word)
                except ValueError:
                    return None
                word = '#%s' % word

                if fetch_tickets:
                    try:
                        ticket = Ticket(self.env, ticketid)
                        if 'TICKET_VIEW' in req.perm(ticket.resource):
                            word = \
                                tag.a(
                                    '#%s' % ticket.id,
                                    class_=ticket['status'],
                                    href=req.href.ticket(int(ticket.id)),
                                    title=shorten_line(ticket['summary'])
                                )
                    except ResourceNotFound:
                        pass

                items.append(word)

        if items:
            return tag(items)
        else:
            return None

 def format_summary(self, summary, status=None, resolution=None, type=None):
     summary = shorten_line(summary)
     if type:
         summary = type + ': ' + summary
     if status:
         if status == 'closed' and resolution:
             status += ': ' + resolution
         return "%s (%s)" % (summary, status)
     else:
         return summary

 def _index_milestone(self, milestone):
     so = FullTextSearchObject(
         self.project,
         milestone.resource,
         title=u"%s: %s" % (milestone.name, shorten_line(milestone.description)),
         changed=milestone.completed or milestone.due or datetime.now(utc),
         involved=(),
         popularity=0,  # FIXME
         oneline=shorten_result(milestone.description),
         body=milestone.description,
     )
     self.backend.create(so, quiet=True)

 def render_timeline_event(self, context, field, event):
     bp_resource, bp, bc = event[3]
     compat_format_0_11_2 = "oneliner"
     if hasattr(context, "_hints"):
         compat_format_0_11_2 = None
     if bc:  # A blog comment
         if field == "url":
             return context.href.blog(bp.name) + "#comment-%d" % bc.number
         elif field == "title":
             return tag("Blog: ", tag.em(bp.title), " comment added")
         elif field == "description":
             comment = compat_format_0_11_2 and shorten_line(bc.comment) or bc.comment
             return format_to(self.env, compat_format_0_11_2, context(resource=bp_resource), comment)
     else:  # A blog post
         if field == "url":
             return context.href.blog(bp.name)
         elif field == "title":
             return tag("Blog: ", tag.em(bp.title), bp.version > 1 and " edited" or " created")
         elif field == "description":
             comment = compat_format_0_11_2 and shorten_line(bp.version_comment) or bp.version_comment
             return format_to(self.env, compat_format_0_11_2, context(resource=bp_resource), comment)

 def _link_textarea(self, req, refs_text):
     items = []
     for ref_id in sorted(cnv_text2list(refs_text)):
         elem = u"#%s" % ref_id
         try:
             ticket = Ticket(self.env, ref_id)
             if "TICKET_VIEW" in req.perm(ticket.resource):
                 title = shorten_line(ticket["summary"])
                 elem = u"#%s %s" % (ref_id, title)
         except ResourceNotFound:
             pass  # not supposed to happen, just in case
         items.extend([elem, u", "])
     return u"".join(item for item in items[:-1])

    def test(self, req, author, content, ip):
        i = req.args.getfirst(self.name)
        h = req.args.getfirst(self.name_hidden)
        r = self.getlink(req)

        if i and h:
            i = shorten_line(javascript_quote(i), 50)
            h = shorten_line(javascript_quote(h), 50)
            return -abs(self.karma_points), \
                   N_("Both trap fields says this is spam (%s, %s)"), i, h
        elif i:
            i = shorten_line(javascript_quote(i), 50)
            return -abs(self.karma_points), \
                   N_("Invisible trap field says this is spam (%s)"), i
        elif h:
            h = shorten_line(javascript_quote(h), 50)
            return -abs(self.karma_points), \
                   N_("Hidden trap field says this is spam (%s)"), h
        elif r:
            r = shorten_line(javascript_quote(r), 50)
            return -abs(self.karma_points), \
                   N_("Register trap field starts with HTTP URL (%s)"), r

 def _link(resource):
     if resource.realm == 'tag':
         # Keep realm selection in tag links.
         return builder.a(resource.id,
                          href=self.get_href(req, tag=resource))
     elif resource.realm == 'ticket':
         # Return resource link including ticket status dependend
         #   class to allow for common Trac ticket link style.
         ticket = Ticket(env, resource.id)
         return builder.a('#%s' % ticket.id,
                          class_=ticket['status'],
                          href=formatter.href.ticket(ticket.id),
                          title=shorten_line(ticket['summary']))
     return render_resource_link(env, context, resource, 'compact')

 def render_property(self, name, mode, context, props):
     repos, value = props[name]
     if name == 'transplant_source':
         try:
             chgset = MercurialChangeset(repos, value)
             link = tag.a(chgset.rev, class_="changeset",
                          title=shorten_line(chgset.message),
                          href=context.href.changeset(short(value),
                                                      repos.reponame))
         except LookupError:
             link = tag.a(hex(value), class_="missing changeset",
                          title=_("no such changeset"), rel="nofollow")
         return RenderedProperty(name=_("Transplant:"), content=link,
                                 name_attributes=[("class", "property")])

    def get_timeline_events(self, req, start, stop, filters):
        if 'changeset' in filters:
            format = req.args.get('format')
            wiki_format = self.wiki_format_messages
            show_files = self.timeline_show_files
            db = self.env.get_db_cnx()
            repos = self.env.get_repository(req.authname)
            for chgset in repos.get_changesets(start, stop):
                message = chgset.message or '--'
                if wiki_format:
                    shortlog = wiki_to_oneliner(message, self.env, db,
                                                shorten=True)
                else:
                    shortlog = shorten_line(message)

                if format == 'rss':
                    title = Markup(u'변경사항 [%s]: %s', chgset.rev, shortlog)
                    href = req.abs_href.changeset(chgset.rev)
                    if wiki_format:
                        message = wiki_to_html(message, self.env, req, db,
                                               absurls=True)
                    else:
                        message = html.PRE(message)
                else:
                    title = Markup(u'변경사항 <em>[%s]</em> : %s에 의해 수정됨', chgset.rev,
                                   chgset.author)
                    href = req.href.changeset(chgset.rev)

                    if wiki_format:
                        if self.timeline_long_messages:
                            message = wiki_to_html(message, self.env, req, db,
                                                   absurls=True)
                        else:
                            message = wiki_to_oneliner(message, self.env, db,
                                                       shorten=True)
                    else:
                        message = shortlog

                if show_files and req.perm.has_permission('BROWSER_VIEW'):
                    files = []
                    for chg in chgset.get_changes():
                        if show_files > 0 and len(files) >= show_files:
                            files.append(html.LI(Markup('&hellip;')))
                            break
                        files.append(html.LI(html.DIV(class_=chg[2]),
                                             chg[0] or '/'))
                    message = html.UL(files, class_="changes") + message

                yield 'changeset', href, title, chgset.date, chgset.author,\
                      message

 def get_search_results(self, req, terms, filters):
     if not 'changeset' in filters:
         return
     repos = self.env.get_repository(req.authname)
     db = self.env.get_db_cnx()
     sql, args = search_to_sql(db, ['message', 'author'], terms)
     cursor = db.cursor()
     cursor.execute("SELECT rev,time,author,message "
                    "FROM revision WHERE " + sql, args)
     for rev, date, author, log in cursor:
         if not repos.authz.has_permission_for_changeset(rev):
             continue
         yield (req.href.changeset(rev),
                '[%s]: %s' % (rev, shorten_line(log)),
                date, author, shorten_result(log, terms))

 def _format_revision_link(self, formatter, ns, reponame, rev, label,
                           fullmatch=None):
     rev, params, fragment = formatter.split_link(rev)
     try:
         repos = RepositoryManager(self.env).get_repository(reponame)
         if repos:
             changeset = repos.get_changeset(rev)
             return tag.a(label, class_="changeset",
                          title=shorten_line(changeset.message),
                          href=(formatter.href.changeset(rev) +
                                params + fragment))
     except NoSuchChangeset:
         pass
     return tag.a(label, class_="missing changeset", rel="nofollow",
                  href=formatter.href.changeset(rev))