home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 January / maximum-cd-2011-01.iso / DiscContents / xbmc-9.11.exe / system / python / spyce / modules / transform.py < prev   
Encoding:
Python Source  |  2009-12-23  |  6.6 KB  |  156 lines
  1. ##################################################
  2. # SPYCE - Python-based HTML Scripting
  3. # Copyright (c) 2002 Rimon Barr.
  4. #
  5. # Refer to spyce.py
  6. # CVS: $Id: transform.py 20864 2009-06-02 06:16:47Z ceros7 $
  7. ##################################################
  8.  
  9. from spyceModule import spyceModule
  10. import types, re, string
  11.  
  12. __doc__ = '''Transform module intercepts different kinds of Spyce ouput, and
  13. can install functions to perform processing. It also includes some standard
  14. Spyce transformation functions.'''
  15.  
  16. OUTPUT_POSITON = 20
  17.  
  18. class transform(spyceModule):
  19.   def start(self):
  20.     self.ident = lambda x, **kwargs: x
  21.     self._filter = FilterFn(self.ident, self.ident, self.ident)
  22.     # install filter functions into response module
  23.     self._prevfilter = self._api.getModule('response').addFilter(OUTPUT_POSITON, self._filter)
  24.   def finish(self, theError=None):
  25.     self._prevfilter = self._api.getModule('response').addFilter(OUTPUT_POSITON, self._prevfilter)
  26.   # set filters
  27.   def dynamic(self, fn=None):
  28.     if not fn: fn = self.ident
  29.     self._filter.dynamicFilter = self.create(fn)
  30.   def static(self, fn=None):
  31.     if not fn: fn = self.ident
  32.     self._filter.staticFilter = self.create(fn)
  33.   def expr(self, fn=None):
  34.     if not fn: fn = self.ident
  35.     self._filter.exprFilter = self.create(fn)
  36.   # create filter
  37.   def create(self, fn):
  38.     '''Create filter function.'''
  39.     if fn==None or fn==() or fn==[]:
  40.       # identity
  41.       return self.ident
  42.     elif type(fn) == types.FunctionType:
  43.       # function type
  44.       return fn
  45.     elif type(fn) == type(''):
  46.       # string
  47.       file_name = string.split(fn, ':')
  48.       if len(file_name)==1: file, name = None, file_name[0]
  49.       else: file, name = file_name[:2]
  50.       if file: fn = loadModule(name, file, self._api.getFilename())
  51.       else: fn = eval(name)
  52.       return fn
  53.     elif type(fn) == type(()) or type(fn) == type([]):
  54.       # tuple or array
  55.       fn0 = self.create(fn[0])
  56.       fn1 = self.create(fn[1:])
  57.       def filterfn(x, _fn0=fn0, _fn1=fn1, **kwargs):
  58.         x = apply(_fn0, (x,), kwargs)
  59.         return apply(_fn1, (x,), kwargs)
  60.       return filterfn
  61.   # commonly used transformations
  62.   def html_encode(self, s, also='', **kwargs):
  63.     '''Return HTML-encoded string.'''
  64.     return html_encode(s, also)
  65.   def url_encode(self, s, **kwargs):
  66.     '''Return url-encoded string.'''
  67.     return url_encode(s)
  68.   def __repr__(self):
  69.     return 'static: %s, expr: %s, dynamic: %s' % (
  70.       str(self._filter.staticFilter!=self.ident),
  71.       str(self._filter.exprFilter!=self.ident),
  72.       str(self._filter.dynamicFilter!=self.ident),
  73.     )
  74.  
  75. class FilterFn(Filter):
  76.   def __init__(self, dynamicFilter=None, staticFilter=None, exprFilter=None):
  77.     ident = lambda x: x
  78.     if not dynamicFilter: dynamicFilter = ident
  79.     if not staticFilter: staticFilter = ident
  80.     if not exprFilter: exprFilter = ident
  81.     self.dynamicFilter = dynamicFilter
  82.     self.staticFilter = staticFilter
  83.     self.exprFilter = exprFilter
  84.   def dynamicImpl(self, s, *args, **kwargs):
  85.     return apply(self.dynamicFilter, (s,)+args, kwargs)
  86.   def staticImpl(self, s, *args, **kwargs):
  87.     return apply(self.staticFilter, (s,)+args, kwargs)
  88.   def exprImpl(self, s, *args, **kwargs):
  89.     return apply(self.exprFilter, (s,)+args, kwargs)
  90.   def flushImpl(self):
  91.     pass
  92.   def clearImpl(self):
  93.     pass
  94.  
  95. # standard transformation functions
  96. def ignore_none(o, **kwargs):
  97.   '''Does not print None.'''
  98.   if o==None: return ''
  99.   else: return o
  100.  
  101. def silence(o, **kwargs):
  102.   '''Gobbles anything.'''
  103.   return ''
  104.  
  105. def truncate(o, maxlen=None, **kwargs):
  106.   '''Limits output to a maximum string length.'''
  107.   if maxlen!=None: return str(o)[:maxlen]
  108.   else: return o
  109.  
  110. _html_enc = { 
  111.   chr(34): '"', chr(38): '&', chr(60): '<', chr(62): '>',
  112.   chr(160): ' ', chr(161): '¡', chr(162): '¢', chr(163): '£',
  113.   chr(164): '¤', chr(165): '¥', chr(166): '¦', chr(167): '§',
  114.   chr(168): '¨', chr(169): '©', chr(170): 'ª', chr(171): '«',
  115.   chr(172): '¬', chr(173): '­', chr(174): '®', chr(175): '¯',
  116.   chr(176): '°', chr(177): '±', chr(178): '²', chr(179): '³',
  117.   chr(180): '´', chr(181): 'µ', chr(182): '¶', chr(183): '·',
  118.   chr(184): '¸', chr(185): '¹', chr(186): 'º', chr(187): '»',
  119.   chr(188): '¼', chr(189): '½', chr(190): '¾', chr(191): '¿',
  120.   chr(192): 'À', chr(193): 'Á', chr(194): 'Â', chr(195): 'Ã',
  121.   chr(196): 'Ä', chr(197): 'Å', chr(198): 'Æ', chr(199): 'Ç',
  122.   chr(200): 'È', chr(201): 'É', chr(202): 'Ê', chr(203): 'Ë',
  123.   chr(204): 'Ì', chr(205): 'Í', chr(206): 'Î', chr(207): 'Ï',
  124.   chr(208): 'Ð', chr(209): 'Ñ', chr(210): 'Ò', chr(211): 'Ó',
  125.   chr(212): 'Ô', chr(213): 'Õ', chr(214): 'Ö', chr(215): '×',
  126.   chr(216): 'Ø', chr(217): 'Ù', chr(218): 'Ú', chr(219): 'Û',
  127.   chr(220): 'Ü', chr(221): 'Ý', chr(222): 'Þ', chr(223): 'ß',
  128.   chr(224): 'à', chr(225): 'á', chr(226): 'â', chr(227): 'ã',
  129.   chr(228): 'ä', chr(229): 'å', chr(230): 'æ', chr(231): 'ç',
  130.   chr(232): 'è', chr(233): 'é', chr(234): 'ê', chr(235): 'ë',
  131.   chr(236): 'ì', chr(237): 'í', chr(238): 'î', chr(239): 'ï',
  132.   chr(240): 'ð', chr(241): 'ñ', chr(242): 'ò', chr(243): 'ó',
  133.   chr(244): 'ô', chr(245): 'õ', chr(246): 'ö', chr(247): '÷',
  134.   chr(248): 'ø', chr(249): 'ù', chr(250): 'ú', chr(251): 'û',
  135.   chr(252): 'ü', chr(253): 'ý', chr(254): 'þ', chr(255): 'ÿ',
  136. }
  137. _html_ch = re.compile(r'['+reduce(lambda n, i: n+i, _html_enc.keys())+']')
  138. def html_encode(o, also='', **kwargs):
  139.   '''Return HTML-encoded string.'''
  140.   o = _html_ch.sub(lambda match: _html_enc[match.group(0)], str(o))
  141.   for c in also:
  142.     try: r=_html_enc[c]
  143.     except: r='&#%d;' % ord(c)
  144.     o=o.replace(c, r)
  145.   return o
  146.  
  147. _url_ch = re.compile(r'[^A-Za-z0-9_.!~*()-]') # RFC 2396 section 2.3
  148. def url_encode(o, **kwargs):
  149.   '''Return URL-encoded string.'''
  150.   return _url_ch.sub(lambda match: "%%%02X" % ord(match.group(0)), str(o))
  151.  
  152. _nb_space_ch = re.compile(' ')
  153. def nb_space(o, **kwargs):
  154.   '''Return string with spaces converted to be non-breaking.'''
  155.   return _nb_space_ch.sub(lambda match: ' ', str(o))
  156.