← Back to branch summary

~loggerhead-team/loggerhead/trunk-rich

« back to all changes in this revision

Viewing changes to loggerhead/util.py

  • Committer: Martin Albisetti
  • Date: 2008-06-23 22:05:20 UTC
  • mto: (157.1.3 loggerhead)
  • mto: This revision was merged to the branch mainline in revision 187.
  • Revision ID: argentina@gmail.com-20080623220520-3prleeajgc3jf2h1
 * Remove download bundle link. That will die soon.
 * Make internal links to files work

Show diffs side-by-side

added added

removed removed

Lines of Context:
loggerhead/util.py
1
1
#
2
 
# Copyright (C) 2008  Canonical Ltd.
3
 
#                     (Authored by Martin Albisetti <argentina@gmail.com)
4
2
# Copyright (C) 2006  Robey Pointer <robey@lag.net>
5
3
# Copyright (C) 2006  Goffredo Baroncelli <kreijack@inwind.it>
6
4
#
29
27
import datetime
30
28
import logging
31
29
import re
 
30
import sha
32
31
import struct
 
32
import sys
33
33
import threading
34
34
import time
 
35
import traceback
35
36
import types
36
37
 
37
38
log = logging.getLogger("loggerhead.controllers")
141
142
        return out
142
143
 
143
144
 
 
145
def clean_revid(revid):
 
146
    if revid == 'missing':
 
147
        return revid
 
148
    return sha.new(revid).hexdigest()
 
149
 
 
150
 
 
151
def obfuscate(text):
 
152
    return ''.join([ '&#%d;' % ord(c) for c in text ])
 
153
 
 
154
 
144
155
def trunc(text, limit=10):
145
156
    if len(text) <= limit:
146
157
        return text
147
158
    return text[:limit] + '...'
148
159
 
149
160
 
 
161
def to_utf8(s):
 
162
    if isinstance(s, unicode):
 
163
        return s.encode('utf-8')
 
164
    return s
 
165
 
 
166
 
150
167
STANDARD_PATTERN = re.compile(r'^(.*?)\s*<(.*?)>\s*$')
151
168
EMAIL_PATTERN = re.compile(r'[-\w\d\+_!%\.]+@[-\w\d\+_!%\.]+')
152
169
 
170
187
    return '%s at %s' % (username, domains[0])
171
188
 
172
189
 
 
190
def triple_factors(min_value=1):
 
191
    factors = (1, 3)
 
192
    index = 0
 
193
    n = 1
 
194
    while True:
 
195
        if n >= min_value:
 
196
            yield n * factors[index]
 
197
        index += 1
 
198
        if index >= len(factors):
 
199
            index = 0
 
200
            n *= 10
 
201
 
 
202
 
 
203
def scan_range(pos, max, pagesize=1):
 
204
    """
 
205
    given a position in a maximum range, return a list of negative and positive
 
206
    jump factors for an hgweb-style triple-factor geometric scan.
 
207
 
 
208
    for example, with pos=20 and max=500, the range would be:
 
209
    [ -10, -3, -1, 1, 3, 10, 30, 100, 300 ]
 
210
 
 
211
    i admit this is a very strange way of jumping through revisions.  i didn't
 
212
    invent it. :)
 
213
    """
 
214
    out = []
 
215
    for n in triple_factors(pagesize + 1):
 
216
        if n > max:
 
217
            return out
 
218
        if pos + n < max:
 
219
            out.append(n)
 
220
        if pos - n >= 0:
 
221
            out.insert(0, -n)
 
222
 
 
223
 
173
224
# only do this if unicode turns out to be a problem
174
225
#_BADCHARS_RE = re.compile(ur'[\u007f-\uffff]')
175
226
 
191
242
    CSS is stupid. In some cases we need to replace an empty value with
192
243
    a non breaking space (&nbsp;). There has to be a better way of doing this.
193
244
 
194
 
    return: the same value recieved if not empty, and a '&nbsp;' if it is.
 
245
    return: the same value recieved if not empty, and a NONBREAKING_SPACE 
 
246
            if not 
195
247
    """
196
 
    
197
 
 
198
 
    if s is None:
199
 
        return '&nbsp;'
200
 
    elif isinstance(s, int):
 
248
    if type(s) is int and s is None:
 
249
        return NONBREAKING_SPACE
 
250
    elif type(s) is int and s is not None:
201
251
        return s
202
 
    elif not s.strip():
203
 
        return '&nbsp;'
 
252
    elif type(s) is types.NoneType:
 
253
        return NONBREAKING_SPACE
 
254
    elif len(s) is 0:
 
255
        return NONBREAKING_SPACE
204
256
    else:
205
 
        try:
206
 
            s = s.decode('utf-8')
207
 
        except UnicodeDecodeError:
208
 
            s = s.decode('iso-8859-15')
209
257
        return s
210
258
 
211
259
 
 
260
 
212
261
def fixed_width(s):
213
262
    """
214
263
    expand tabs and turn spaces into "non-breaking spaces", so browsers won't
236
285
    return '-rw-r--r--'
237
286
 
238
287
 
 
288
def if_present(format, value):
 
289
    """
 
290
    format a value using a format string, if the value exists and is not None.
 
291
    """
 
292
    if value is None:
 
293
        return ''
 
294
    return format % value
 
295
 
 
296
 
239
297
def b64(s):
240
298
    s = base64.encodestring(s).replace('\n', '')
241
299
    while (len(s) > 0) and (s[-1] == '='):
318
376
    navigation.last_in_page_revid = get_offset(navigation.pagesize - 1)
319
377
    navigation.prev_page_revid = get_offset(-1 * navigation.pagesize)
320
378
    navigation.next_page_revid = get_offset(1 * navigation.pagesize)
321
 
    prev_page_revno = navigation.history.get_revno(
322
 
            navigation.prev_page_revid)
323
 
    next_page_revno = navigation.history.get_revno(
324
 
            navigation.next_page_revid)
325
 
    start_revno = navigation.history.get_revno(navigation.start_revid)
 
379
    prev_page_revno = navigation.branch.history.get_revno(
 
380
            navigation.prev_page_revid)
 
381
    next_page_revno = navigation.branch.history.get_revno(
 
382
            navigation.next_page_revid)
 
383
    start_revno = navigation.branch._history.get_revno(navigation.start_revid)
 
384
 
 
385
    prev_page_revno = navigation.branch._history.get_revno(
 
386
            navigation.prev_page_revid)
 
387
    next_page_revno = navigation.branch._history.get_revno(
 
388
            navigation.next_page_revid)
326
389
 
327
390
    params = { 'filter_file_id': navigation.filter_file_id }
328
391
    if getattr(navigation, 'query', None) is not None:
339
402
            [navigation.scan_url, next_page_revno], **params)
340
403
 
341
404
 
 
405
def log_exception(log):
 
406
    for line in ''.join(traceback.format_exception(*sys.exc_info())).split('\n'):
 
407
        log.debug(line)
 
408
 
 
409
 
342
410
def decorator(unbound):
343
411
    def new_decorator(f):
344
412
        g = unbound(f)
369
437
 
370
438
 
371
439
@decorator
 
440
def strip_whitespace(f):
 
441
    def _f(*a, **kw):
 
442
        out = f(*a, **kw)
 
443
        orig_len = len(out)
 
444
        out = re.sub(r'\n\s+', '\n', out)
 
445
        out = re.sub(r'[ \t]+', ' ', out)
 
446
        out = re.sub(r'\s+\n', '\n', out)
 
447
        new_len = len(out)
 
448
        log.debug('Saved %sB (%d%%) by stripping whitespace.',
 
449
                  human_size(orig_len - new_len),
 
450
                  round(100.0 - float(new_len) * 100.0 / float(orig_len)))
 
451
        return out
 
452
    return _f
 
453
 
 
454
 
 
455
@decorator
372
456
def lsprof(f):
373
457
    def _f(*a, **kw):
374
458
        from loggerhead.lsprof import profile