19
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34
from xml.etree import ElementTree as ET
36
from elementtree import ElementTree as ET
38
from bzrlib import urlutils
40
from simpletal.simpleTALUtils import HTMLStructureCleaner
42
log = logging.getLogger("loggerhead.controllers")
54
# date_day -- just the day
55
# date_time -- full date with time
57
# displaydate -- for use in sentences
58
# approximatedate -- for use in tables
60
# displaydate and approximatedate return an elementtree <span> Element
61
# with the full date in a tooltip.
65
return value.strftime('%Y-%m-%d')
70
return value.strftime('%Y-%m-%d %H:%M:%S')
75
def _displaydate(date):
76
delta = abs(datetime.datetime.now() - date)
77
if delta > datetime.timedelta(1, 0, 0):
78
# far in the past or future, display the date
79
return 'on ' + date_day(date)
80
return _approximatedate(date)
83
def _approximatedate(date):
84
delta = datetime.datetime.now() - date
85
if abs(delta) > datetime.timedelta(1, 0, 0):
86
# far in the past or future, display the date
88
future = delta < datetime.timedelta(0, 0, 0)
91
hours = delta.seconds / 3600
92
minutes = (delta.seconds - (3600*hours)) / 60
93
seconds = delta.seconds % 60
111
result += '%s %s' % (amount, unit)
117
def _wrap_with_date_time_title(date, formatted_date):
118
elem = ET.Element("span")
119
elem.text = formatted_date
120
elem.set("title", date_time(date))
124
def approximatedate(date):
125
#FIXME: Returns an object instead of a string
126
return _wrap_with_date_time_title(date, _approximatedate(date))
129
def displaydate(date):
130
return _wrap_with_date_time_title(date, _displaydate(date))
133
class Container(object):
25
return '%d days' % delta.days
31
seg.append('%d days' % delta.days)
32
hrs = delta.seconds // 3600
33
mins = (delta.seconds % 3600) // 60
38
seg.append('%d hours' % hrs)
42
seg.append('1 minute')
44
seg.append('%d minutes' % mins)
46
seg.append('less than a minute')
50
class Container (object):
135
52
Convert a dict into an object with attributes.
138
54
def __init__(self, _dict=None, **kw):
139
self._properties = {}
140
55
if _dict is not None:
141
56
for key, value in _dict.iteritems():
142
57
setattr(self, key, value)
143
58
for key, value in kw.iteritems():
144
59
setattr(self, key, value)
148
for key, value in self.__dict__.iteritems():
149
if key.startswith('_') or (getattr(self.__dict__[key],
150
'__call__', None) is not None):
152
out += '%r => %r, ' % (key, value)
156
def __getattr__(self, attr):
157
"""Used for handling things that aren't already available."""
158
if attr.startswith('_') or attr not in self._properties:
159
raise AttributeError('No attribute: %s' % (attr,))
160
val = self._properties[attr](self, attr)
161
setattr(self, attr, val)
164
def _set_property(self, attr, prop_func):
165
"""Set a function that will be called when an attribute is desired.
167
We will cache the return value, so the function call should be
168
idempotent. We will pass 'self' and the 'attr' name when triggered.
170
if attr.startswith('_'):
171
raise ValueError("Cannot create properties that start with _")
172
self._properties[attr] = prop_func
175
def trunc(text, limit=10):
176
if len(text) <= limit:
178
return text[:limit] + '...'
62
def clean_revid(revid):
63
if revid == 'missing':
65
return sha.new(revid).hexdigest()
69
return ''.join([ '&#%d;' % ord(c) for c in text ])
181
72
STANDARD_PATTERN = re.compile(r'^(.*?)\s*<(.*?)>\s*$')
182
73
EMAIL_PATTERN = re.compile(r'[-\w\d\+_!%\.]+@[-\w\d\+_!%\.]+')
185
75
def hide_email(email):
187
77
try to obsure any email address in a bazaar committer's name.
201
91
return '%s at %s' % (username, domains[-2])
202
92
return '%s at %s' % (username, domains[0])
204
def hide_emails(emails):
206
try to obscure any email address in a list of bazaar committers' names.
210
result.append(hide_email(email))
213
# only do this if unicode turns out to be a problem
214
#_BADCHARS_RE = re.compile(ur'[\u007f-\uffff]')
216
# Can't be a dict; & needs to be done first.
220
("'", "'"), # ' is defined in XML, but not HTML.
227
"""Transform dangerous (X)HTML characters into entities.
229
Like cgi.escape, except also escaping " and '. This makes it safe to use
230
in both attribute and element content.
232
If you want to safely fill a format string with escaped values, use
235
for char, repl in html_entity_subs:
236
s = s.replace(char, repl)
240
def html_format(template, *args):
241
"""Safely format an HTML template string, escaping the arguments.
243
The template string must not be user-controlled; it will not be escaped.
245
return template % tuple(html_escape(arg) for arg in args)
248
# FIXME: get rid of this method; use fixed_width() and avoid XML().
252
clean up a string for html display. expand any tabs, encode any html
253
entities, and replace spaces with ' '. this is primarily for use
254
in displaying monospace text.
256
s = html_escape(s.expandtabs())
257
s = s.replace(' ', ' ')
261
NONBREAKING_SPACE = u'\N{NO-BREAK SPACE}'
266
CSS is stupid. In some cases we need to replace an empty value with
267
a non breaking space ( ). There has to be a better way of doing this.
269
return: the same value recieved if not empty, and a ' ' if it is.
273
elif isinstance(s, int):
279
s = s.decode('utf-8')
280
except UnicodeDecodeError:
281
s = s.decode('iso-8859-15')
284
HSC = HTMLStructureCleaner()
288
expand tabs and turn spaces into "non-breaking spaces", so browsers won't
291
if not isinstance(s, unicode):
292
# this kinda sucks. file contents are just binary data, and no
293
# encoding metadata is stored, so we need to guess. this is probably
294
# okay for most code, but for people using things like KOI-8, this
295
# will display gibberish. we have no way of detecting the correct
298
s = s.decode('utf-8')
299
except UnicodeDecodeError:
300
s = s.decode('iso-8859-15')
302
s = html_escape(s).expandtabs().replace(' ', NONBREAKING_SPACE)
304
return HSC.clean(s).replace('\n', '<br/>')
307
def fake_permissions(kind, executable):
308
# fake up unix-style permissions given only a "kind" and executable bit
309
if kind == 'directory':
317
s = base64.encodestring(s).replace('\n', '')
318
while (len(s) > 0) and (s[-1] == '='):
325
turn a potentially long string into a unique smaller string.
329
uniqs[type(None)] = next = uniqs.get(type(None), 0) + 1
330
x = struct.pack('>I', next)
331
while (len(x) > 1) and (x[0] == '\x00'):
340
P95_MEG = int(0.9 * MEG)
341
P95_GIG = int(0.9 * GIG)
344
def human_size(size, min_divisor=0):
346
if (size == 0) and (min_divisor == 0):
348
if (size < 512) and (min_divisor == 0):
351
if (size >= P95_GIG) or (min_divisor >= GIG):
353
elif (size >= P95_MEG) or (min_divisor >= MEG):
360
dot = dot * 10 // divisor
367
if (base < 100) and (dot != 0):
368
out += '.%d' % (dot,)
378
def local_path_from_url(url):
379
"""Convert Bazaar URL to local path, ignoring readonly+ prefix"""
380
readonly_prefix = 'readonly+'
381
if url.startswith(readonly_prefix):
382
url = url[len(readonly_prefix):]
383
return urlutils.local_path_from_url(url)
386
def fill_in_navigation(navigation):
388
given a navigation block (used by the template for the page header), fill
389
in useful calculated values.
391
if navigation.revid in navigation.revid_list: # XXX is this always true?
392
navigation.position = navigation.revid_list.index(navigation.revid)
394
navigation.position = 0
395
navigation.count = len(navigation.revid_list)
396
navigation.page_position = navigation.position // navigation.pagesize + 1
397
navigation.page_count = (len(navigation.revid_list) + (navigation.pagesize\
398
- 1)) // navigation.pagesize
400
def get_offset(offset):
401
if (navigation.position + offset < 0) or (
402
navigation.position + offset > navigation.count - 1):
404
return navigation.revid_list[navigation.position + offset]
406
navigation.last_in_page_revid = get_offset(navigation.pagesize - 1)
407
navigation.prev_page_revid = get_offset(-1 * navigation.pagesize)
408
navigation.next_page_revid = get_offset(1 * navigation.pagesize)
409
prev_page_revno = navigation.history.get_revno(
410
navigation.prev_page_revid)
411
next_page_revno = navigation.history.get_revno(
412
navigation.next_page_revid)
413
start_revno = navigation.history.get_revno(navigation.start_revid)
415
params = {'filter_file_id': navigation.filter_file_id}
416
if getattr(navigation, 'query', None) is not None:
417
params['q'] = navigation.query
419
if getattr(navigation, 'start_revid', None) is not None:
420
params['start_revid'] = start_revno
422
if navigation.prev_page_revid:
423
navigation.prev_page_url = navigation.branch.context_url(
424
[navigation.scan_url, prev_page_revno], **params)
425
if navigation.next_page_revid:
426
navigation.next_page_url = navigation.branch.context_url(
427
[navigation.scan_url, next_page_revno], **params)
430
def directory_breadcrumbs(path, is_root, view):
432
Generate breadcrumb information from the directory path given
434
The path given should be a path up to any branch that is currently being
438
path -- The path to convert into breadcrumbs
439
is_root -- Whether or not loggerhead is serving a branch at its root
440
view -- The type of view we are showing (files, changes etc)
442
# Is our root directory itself a branch?
450
# Create breadcrumb trail for the path leading up to the branch
452
'dir_name': "(root)",
457
dir_parts = path.strip('/').split('/')
458
for index, dir_name in enumerate(dir_parts):
460
'dir_name': dir_name,
461
'path': '/'.join(dir_parts[:index + 1]),
464
# If we are not in the directory view, the last crumb is a branch,
465
# so we need to specify a view
466
if view != 'directory':
467
breadcrumbs[-1]['suffix'] = '/' + view
471
def branch_breadcrumbs(path, inv, view):
473
Generate breadcrumb information from the branch path given
475
The path given should be a path that exists within a branch
478
path -- The path to convert into breadcrumbs
479
inv -- Inventory to get file information from
480
view -- The type of view we are showing (files, changes etc)
482
dir_parts = path.strip('/').split('/')
483
inner_breadcrumbs = []
484
for index, dir_name in enumerate(dir_parts):
485
inner_breadcrumbs.append({
486
'dir_name': dir_name,
487
'file_id': inv.path2id('/'.join(dir_parts[:index + 1])),
488
'suffix': '/' + view,
490
return inner_breadcrumbs
493
def decorator(unbound):
495
def new_decorator(f):
497
g.__name__ = f.__name__
498
g.__doc__ = f.__doc__
499
g.__dict__.update(f.__dict__)
501
new_decorator.__name__ = unbound.__name__
502
new_decorator.__doc__ = unbound.__doc__
503
new_decorator.__dict__.update(unbound.__dict__)
512
from loggerhead.lsprof import profile
515
ret, stats = profile(f, *a, **kw)
516
log.debug('Finished profiled %s in %d msec.' % (f.__name__,
517
int((time.time() - z) * 1000)))
521
msec = int(now * 1000) % 1000
522
timestr = time.strftime('%Y%m%d%H%M%S',
523
time.localtime(now)) + ('%03d' % (msec,))
524
filename = f.__name__ + '-' + timestr + '.lsprof'
525
cPickle.dump(stats, open(filename, 'w'), 2)
530
# just thinking out loud here...
532
# so, when browsing around, there are 5 pieces of context, most optional:
534
# current location along the navigation path (while browsing)
535
# - starting revid (start_revid)
536
# the current beginning of navigation (navigation continues back to
537
# the original revision) -- this defines an 'alternate mainline'
538
# when the user navigates into a branch.
540
# the file being looked at
542
# if navigating the revisions that touched a file
544
# if navigating the revisions that matched a search query
546
# a previous revision to remember for future comparisons
548
# current revid is given on the url path. the rest are optional components
551
# other transient things can be set:
553
# to compare one revision to another, on /revision only
555
# for re-ordering an existing page by different sort
557
t_context = threading.local()
558
_valid = ('start_revid', 'file_id', 'filter_file_id', 'q', 'remember',
559
'compare_revid', 'sort')
562
def set_context(map):
563
t_context.map = dict((k, v) for (k, v) in map.iteritems() if k in _valid)
566
def get_context(**overrides):
568
Soon to be deprecated.
571
return a context map that may be overriden by specific values passed in,
572
but only contains keys from the list of valid context keys.
574
if 'clear' is set, only the 'remember' context value will be added, and
575
all other context will be omitted.
578
if overrides.get('clear', False):
579
map['remember'] = t_context.map.get('remember', None)
581
map.update(t_context.map)
582
overrides = dict((k, v) for (k, v) in overrides.iteritems() if k in _valid)
583
map.update(overrides)
587
class Reloader(object):
589
This class wraps all paste.reloader logic. All methods are @classmethod.
592
_reloader_environ_key = 'PYTHON_RELOADER_SHOULD_RUN'
595
def _turn_sigterm_into_systemexit(cls):
597
Attempts to turn a SIGTERM exception into a SystemExit exception.
604
def handle_term(signo, frame):
606
signal.signal(signal.SIGTERM, handle_term)
609
def is_installed(cls):
610
return os.environ.get(cls._reloader_environ_key)
614
from paste import reloader
615
reloader.install(int(1))
618
def restart_with_reloader(cls):
619
"""Based on restart_with_monitor from paste.script.serve."""
620
print 'Starting subprocess with file monitor'
622
args = [sys.executable] + sys.argv
623
new_environ = os.environ.copy()
624
new_environ[cls._reloader_environ_key] = 'true'
628
cls._turn_sigterm_into_systemexit()
629
proc = subprocess.Popen(args, env=new_environ)
630
exit_code = proc.wait()
632
except KeyboardInterrupt:
633
print '^C caught in monitor process'
637
and getattr(os, 'kill', None) is not None):
640
os.kill(proc.pid, signal.SIGTERM)
641
except (OSError, IOError):
644
# Reloader always exits with code 3; but if we are
645
# a monitor, any exit code will restart
648
print '-'*20, 'Restarting', '-'*20
651
def convert_file_errors(application):
652
"""WSGI wrapper to convert some file errors to Paste exceptions"""
653
def new_application(environ, start_response):
655
return application(environ, start_response)
656
except (IOError, OSError), e:
658
from paste import httpexceptions
659
if e.errno == errno.ENOENT:
660
raise httpexceptions.HTTPNotFound()
661
elif e.errno == errno.EACCES:
662
raise httpexceptions.HTTPForbidden()
665
return new_application
668
def convert_to_json_ready(obj):
669
if isinstance(obj, Container):
670
d = obj.__dict__.copy()
673
elif isinstance(obj, datetime.datetime):
674
return tuple(obj.utctimetuple())
675
raise TypeError(repr(obj) + " is not JSON serializable")
100
yield n * factors[index]
102
if index >= len(factors):
107
def scan_range(pos, max):
109
given a position in a maximum range, return a list of negative and positive
110
jump factors for an hgweb-style triple-factor geometric scan.
112
for example, with pos=20 and max=500, the range would be:
113
[ -10, -3, -1, 1, 3, 10, 30, 100, 300 ]
115
i admit this is a very strange way of jumping through revisions. i didn't
119
for n in triple_factors():
added
removed
loggerhead/util.py
