~loggerhead-team/loggerhead/trunk-rich

import cgi

import sha

import sys

import traceback

 

def timespan(delta):

    if delta.days > 730:

        # good grief!

        return '%d years' % (int(delta.days // 365.25),)

    if delta.days >= 3:

        return '%d days' % delta.days

    seg = []

    if delta.days > 0:

        if delta.days == 1:

            seg.append('1 day')

        else:

            seg.append('%d days' % delta.days)

    hrs = delta.seconds // 3600

    mins = (delta.seconds % 3600) // 60

    if hrs > 0:

        if hrs == 1:

            seg.append('1 hour')

        else:

            seg.append('%d hours' % hrs)

    if delta.days == 0:

        if mins > 0:

            if mins == 1:

                seg.append('1 minute')

            else:

                seg.append('%d minutes' % mins)

        elif hrs == 0:

            seg.append('less than a minute')

    return ', '.join(seg)

 

 

def ago(timestamp):

    now = datetime.datetime.now()

    return timespan(now - timestamp) + ' ago'

 

 

 

_g_format = '%Y-%m-%d @ %H:%M'

 

def format_date(date):

    if _g_format == 'fancy':

        return fancy_format_date(date)

    return date.strftime(_g_format)

 

def fancy_format_date(date):

    if delta.days > 300:

        return date.strftime('%d %b %Y')

        return date.strftime('%d %b %H:%M')

 

def set_date_format(format):

    global _g_format

    _g_format = format

 

 

class Container (object):

            if key.startswith('_') or (getattr(self.__dict__[key], '__call__', None) is not None):

 

def clean_revid(revid):

    if revid == 'missing':

        return revid

    return sha.new(revid).hexdigest()

 

 

def obfuscate(text):

    return ''.join([ '&#%d;' % ord(c) for c in text ])

def to_utf8(s):

    if isinstance(s, unicode):

        return s.encode('utf-8')

    return s

 

 

 

def triple_factors(min_value=1):

    factors = (1, 3)

    index = 0

    n = 1

    while True:

        if n >= min_value:

            yield n * factors[index]

        index += 1

        if index >= len(factors):

            index = 0

            n *= 10

 

 

def scan_range(pos, max, pagesize=1):

    """

    given a position in a maximum range, return a list of negative and positive

    jump factors for an hgweb-style triple-factor geometric scan.

 

    for example, with pos=20 and max=500, the range would be:

    [ -10, -3, -1, 1, 3, 10, 30, 100, 300 ]

 

    i admit this is a very strange way of jumping through revisions.  i didn't

    invent it. :)

    """

    out = []

    for n in triple_factors(pagesize + 1):

        if n > max:

            return out

        if pos + n < max:

            out.append(n)

        if pos - n >= 0:

            out.insert(0, -n)

 

    s = cgi.escape(s.expandtabs())

 

    return s.expandtabs().replace(' ', NONBREAKING_SPACE)

def if_present(format, value):

    """

    format a value using a format string, if the value exists and is not None.

    """

    if value is None:

        return ''

    return format % value

 

 

    navigation.page_count = (len(navigation.revid_list) + (navigation.pagesize - 1)) // navigation.pagesize

        if (navigation.position + offset < 0) or (navigation.position + offset > navigation.count - 1):

    params = { 'file_id': navigation.file_id }

    else:

        params['start_revid'] = navigation.start_revid

        navigation.prev_page_url = navigation.branch.url([ navigation.scan_url, navigation.prev_page_revid ], **get_context(**params))

        navigation.next_page_url = navigation.branch.url([ navigation.scan_url, navigation.next_page_revid ], **get_context(**params))

 

 

def log_exception(log):

    for line in ''.join(traceback.format_exception(*sys.exc_info())).split('\n'):

        log.debug(line)

# common threading-lock decorator

def with_lock(lockname, debug_name=None):

    if debug_name is None:

        debug_name = lockname

    @decorator

    def _decorator(unbound):

        def locked(self, *args, **kw):

            getattr(self, lockname).acquire()

            try:

                return unbound(self, *args, **kw)

            finally:

                getattr(self, lockname).release()

        return locked

    return _decorator

 

 

@decorator

def strip_whitespace(f):

    def _f(*a, **kw):

        out = f(*a, **kw)

        orig_len = len(out)

        out = re.sub(r'\n\s+', '\n', out)

        out = re.sub(r'[ \t]+', ' ', out)

        out = re.sub(r'\s+\n', '\n', out)

        new_len = len(out)

        log.debug('Saved %sB (%d%%) by stripping whitespace.',

                  human_size(orig_len - new_len),

                  round(100.0 - float(new_len) * 100.0 / float(orig_len)))

        return out

    return _f

 

        log.debug('Finished profiled %s in %d msec.' % (f.__name__, int((time.time() - z) * 1000)))

        timestr = time.strftime('%Y%m%d%H%M%S', time.localtime(now)) + ('%03d' % msec)

#         the original revision) -- this may not be along the primary revision

#         path since the user may have navigated into a branch

_valid = ('start_revid', 'file_id', 'q', 'remember', 'compare_revid', 'sort')