Python text.shorten_line函数代码示例

 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