home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2390 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  13.3 KB  |  559 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import re
  5. import sys
  6. import urllib
  7. if sys.version < '2.4':
  8.     from sets import ImmutableSet as frozenset
  9.  
  10. from routes.util import _url_quote as url_quote, _str_encode
  11.  
  12. class Route(object):
  13.     reserved_keys = [
  14.         'requirements']
  15.     done_chars = ('/', ',', ';', '.', '#')
  16.     
  17.     def __init__(self, name, routepath, **kargs):
  18.         self.routepath = routepath
  19.         self.sub_domains = False
  20.         self.prior = None
  21.         self.redirect = False
  22.         self.name = name
  23.         self._kargs = kargs
  24.         self.minimization = kargs.pop('_minimize', False)
  25.         self.encoding = kargs.pop('_encoding', 'utf-8')
  26.         self.reqs = kargs.get('requirements', { })
  27.         self.decode_errors = 'replace'
  28.         self.static = kargs.pop('_static', False)
  29.         self.filter = kargs.pop('_filter', None)
  30.         self.absolute = kargs.pop('_absolute', False)
  31.         self.member_name = kargs.pop('_member_name', None)
  32.         self.collection_name = kargs.pop('_collection_name', None)
  33.         self.parent_resource = kargs.pop('_parent_resource', None)
  34.         self.conditions = kargs.pop('conditions', None)
  35.         self.explicit = kargs.pop('_explicit', False)
  36.         if self.static:
  37.             self.external = '://' in self.routepath
  38.             self.minimization = False
  39.         
  40.         if routepath.startswith('/') and self.minimization:
  41.             self.routepath = routepath[1:]
  42.         
  43.         self._setup_route()
  44.  
  45.     
  46.     def _setup_route(self):
  47.         self.routelist = routelist = self._pathkeys(self.routepath)
  48.         routekeys = [](_[1])
  49.         self.dotkeys = [](_[2])
  50.         self.req_regs = { }
  51.         for key, val in self.reqs.iteritems():
  52.             self.req_regs[key] = re.compile('^' + val + '$')
  53.         
  54.         (self.defaults, defaultkeys) = self._defaults(routekeys, self.reserved_keys, self._kargs.copy())
  55.         self.maxkeys = defaultkeys | routekeys
  56.         (self.minkeys, self.routebackwards) = self._minkeys(routelist[:])
  57.         self.hardcoded = [](_[3])
  58.         self._default_keys = frozenset(self.defaults.keys())
  59.  
  60.     
  61.     def make_full_route(self):
  62.         regpath = ''
  63.         for part in self.routelist:
  64.             if isinstance(part, dict):
  65.                 regpath += '%(' + part['name'] + ')s'
  66.                 continue
  67.             regpath += part
  68.         
  69.         self.regpath = regpath
  70.  
  71.     
  72.     def make_unicode(self, s):
  73.         if isinstance(s, unicode):
  74.             return s
  75.         if isinstance(s, str):
  76.             return s.decode(self.encoding)
  77.         if callable(s):
  78.             return s
  79.         return unicode(s)
  80.  
  81.     
  82.     def _pathkeys(self, routepath):
  83.         collecting = False
  84.         current = ''
  85.         done_on = ''
  86.         var_type = ''
  87.         just_started = False
  88.         routelist = []
  89.         for char in routepath:
  90.             if (char in (':', '*', '{') and not collecting or not (self.static) or char in ('{',)) and not collecting:
  91.                 just_started = True
  92.                 collecting = True
  93.                 var_type = char
  94.                 if char == '{':
  95.                     done_on = '}'
  96.                     just_started = False
  97.                 
  98.                 if len(current) > 0:
  99.                     routelist.append(current)
  100.                     current = ''
  101.                 
  102.             len(current) > 0
  103.             if collecting and just_started:
  104.                 just_started = False
  105.                 if char == '(':
  106.                     done_on = ')'
  107.                 else:
  108.                     current = char
  109.                     done_on = self.done_chars + ('-',)
  110.             char == '('
  111.             if collecting and char not in done_on:
  112.                 current += char
  113.                 continue
  114.             if collecting:
  115.                 collecting = False
  116.                 if var_type == '{':
  117.                     if current[0] == '.':
  118.                         var_type = '.'
  119.                         current = current[1:]
  120.                     else:
  121.                         var_type = ':'
  122.                     opts = current.split(':')
  123.                     if len(opts) > 1:
  124.                         current = opts[0]
  125.                         self.reqs[current] = opts[1]
  126.                     
  127.                 
  128.                 routelist.append(dict(type = var_type, name = current))
  129.                 if char in self.done_chars:
  130.                     routelist.append(char)
  131.                 
  132.                 done_on = var_type = current = ''
  133.                 continue
  134.             current += char
  135.         
  136.         if collecting:
  137.             routelist.append(dict(type = var_type, name = current))
  138.         elif current:
  139.             routelist.append(current)
  140.         
  141.         return routelist
  142.  
  143.     
  144.     def _minkeys(self, routelist):
  145.         minkeys = []
  146.         backcheck = routelist[:]
  147.         if not self.minimization:
  148.             for part in backcheck:
  149.                 if isinstance(part, dict):
  150.                     minkeys.append(part['name'])
  151.                     continue
  152.             
  153.             return (frozenset(minkeys), backcheck)
  154.         gaps = False
  155.         backcheck.reverse()
  156.         for part in backcheck:
  157.             if not isinstance(part, dict) and part not in self.done_chars:
  158.                 gaps = True
  159.                 continue
  160.             elif not isinstance(part, dict):
  161.                 continue
  162.             
  163.             key = part['name']
  164.             if self.defaults.has_key(key) and not gaps:
  165.                 continue
  166.             
  167.             minkeys.append(key)
  168.             gaps = True
  169.         
  170.         return (frozenset(minkeys), backcheck)
  171.  
  172.     
  173.     def _defaults(self, routekeys, reserved_keys, kargs):
  174.         defaults = { }
  175.         if 'controller' not in routekeys and 'controller' not in kargs and not (self.explicit):
  176.             kargs['controller'] = 'content'
  177.         
  178.         if 'action' not in routekeys and 'action' not in kargs and not (self.explicit):
  179.             kargs['action'] = 'index'
  180.         
  181.         defaultkeys = [](_[1])
  182.         for key in defaultkeys:
  183.             if kargs[key] is not None:
  184.                 defaults[key] = self.make_unicode(kargs[key])
  185.                 continue
  186.             []
  187.             defaults[key] = None
  188.         
  189.         if 'action' in routekeys and not defaults.has_key('action') and not (self.explicit):
  190.             defaults['action'] = 'index'
  191.         
  192.         if 'id' in routekeys and not defaults.has_key('id') and not (self.explicit):
  193.             defaults['id'] = None
  194.         
  195.         newdefaultkeys = [](_[2])
  196.         return (defaults, newdefaultkeys)
  197.  
  198.     
  199.     def makeregexp(self, clist, include_names = True):
  200.         if self.minimization:
  201.             reg = self.buildnextreg(self.routelist, clist, include_names)[0]
  202.             if not reg:
  203.                 reg = '/'
  204.             
  205.             reg = reg + '/?' + '$'
  206.             if not reg.startswith('/'):
  207.                 reg = '/' + reg
  208.             
  209.         else:
  210.             reg = self.buildfullreg(clist, include_names)
  211.         reg = '^' + reg
  212.         if not include_names:
  213.             return reg
  214.         self.regexp = reg
  215.         self.regmatch = re.compile(reg)
  216.  
  217.     
  218.     def buildfullreg(self, clist, include_names = True):
  219.         regparts = []
  220.         for part in self.routelist:
  221.             if isinstance(part, dict):
  222.                 var = part['name']
  223.                 if var == 'controller':
  224.                     partmatch = '|'.join(map(re.escape, clist))
  225.                 elif part['type'] == ':':
  226.                     if not self.reqs.get(var):
  227.                         pass
  228.                     partmatch = '[^/]+?'
  229.                 elif part['type'] == '.':
  230.                     if not self.reqs.get(var):
  231.                         pass
  232.                     partmatch = '[^/.]+?'
  233.                 elif not self.reqs.get(var):
  234.                     pass
  235.                 partmatch = '.+?'
  236.                 if include_names:
  237.                     regpart = '(?P<%s>%s)' % (var, partmatch)
  238.                 else:
  239.                     regpart = '(?:%s)' % partmatch
  240.                 if part['type'] == '.':
  241.                     regparts.append('(?:\\.%s)??' % regpart)
  242.                 else:
  243.                     regparts.append(regpart)
  244.             part['type'] == '.'
  245.             regparts.append(re.escape(part))
  246.         
  247.         regexp = ''.join(regparts) + '$'
  248.         return regexp
  249.  
  250.     
  251.     def buildnextreg(self, path, clist, include_names = True):
  252.         if path:
  253.             part = path[0]
  254.         else:
  255.             part = ''
  256.         reg = ''
  257.         rest = ''
  258.         noreqs = True
  259.         allblank = True
  260.         if len(path[1:]) > 0:
  261.             self.prior = part
  262.             (rest, noreqs, allblank) = self.buildnextreg(path[1:], clist, include_names)
  263.         
  264.         if isinstance(part, dict) and part['type'] in (':', '.'):
  265.             var = part['name']
  266.             typ = part['type']
  267.             partreg = ''
  268.             if self.reqs.has_key(var):
  269.                 if include_names:
  270.                     partreg = '(?P<%s>%s)' % (var, self.reqs[var])
  271.                 else:
  272.                     partreg = '(?:%s)' % self.reqs[var]
  273.                 if typ == '.':
  274.                     partreg = '(?:\\.%s)??' % partreg
  275.                 
  276.             elif var == 'controller':
  277.                 if include_names:
  278.                     partreg = '(?P<%s>%s)' % (var, '|'.join(map(re.escape, clist)))
  279.                 else:
  280.                     partreg = '(?:%s)' % '|'.join(map(re.escape, clist))
  281.             elif self.prior in ('/', '#'):
  282.                 if include_names:
  283.                     partreg = '(?P<' + var + '>[^' + self.prior + ']+?)'
  284.                 else:
  285.                     partreg = '(?:[^' + self.prior + ']+?)'
  286.             elif not rest:
  287.                 if typ == '.':
  288.                     exclude_chars = '/.'
  289.                 else:
  290.                     exclude_chars = '/'
  291.                 if include_names:
  292.                     partreg = '(?P<%s>[^%s]+?)' % (var, exclude_chars)
  293.                 else:
  294.                     partreg = '(?:[^%s]+?)' % exclude_chars
  295.                 if typ == '.':
  296.                     partreg = '(?:\\.%s)??' % partreg
  297.                 
  298.             else:
  299.                 end = ''.join(self.done_chars)
  300.                 rem = rest
  301.                 if rem[0] == '\\' and len(rem) > 1:
  302.                     rem = rem[1]
  303.                 elif rem.startswith('(\\') and len(rem) > 2:
  304.                     rem = rem[2]
  305.                 else:
  306.                     rem = end
  307.                 rem = frozenset(rem) | frozenset([
  308.                     '/'])
  309.                 if include_names:
  310.                     partreg = '(?P<%s>[^%s]+?)' % (var, ''.join(rem))
  311.                 else:
  312.                     partreg = '(?:[^%s]+?)' % ''.join(rem)
  313.             if self.reqs.has_key(var):
  314.                 noreqs = False
  315.             
  316.             if not self.defaults.has_key(var):
  317.                 allblank = False
  318.                 noreqs = False
  319.             
  320.             if noreqs:
  321.                 if self.reqs.has_key(var) and self.defaults.has_key(var):
  322.                     reg = '(' + partreg + rest + ')?'
  323.                 elif self.reqs.has_key(var):
  324.                     allblank = False
  325.                     reg = partreg + rest
  326.                 elif self.defaults.has_key(var) and self.prior in (',', ';', '.'):
  327.                     reg = partreg + rest
  328.                 elif self.defaults.has_key(var):
  329.                     reg = partreg + '?' + rest
  330.                 else:
  331.                     allblank = False
  332.                     reg = partreg + rest
  333.             elif allblank and self.defaults.has_key(var):
  334.                 reg = '(' + partreg + rest + ')?'
  335.             else:
  336.                 reg = partreg + rest
  337.         elif isinstance(part, dict) and part['type'] == '*':
  338.             var = part['name']
  339.             if noreqs:
  340.                 if include_names:
  341.                     reg = '(?P<%s>.*)' % var + rest
  342.                 else:
  343.                     reg = '(?:.*)' + rest
  344.                 if not self.defaults.has_key(var):
  345.                     allblank = False
  346.                     noreqs = False
  347.                 
  348.             elif allblank and self.defaults.has_key(var):
  349.                 if include_names:
  350.                     reg = '(?P<%s>.*)' % var + rest
  351.                 else:
  352.                     reg = '(?:.*)' + rest
  353.             elif self.defaults.has_key(var):
  354.                 if include_names:
  355.                     reg = '(?P<%s>.*)' % var + rest
  356.                 else:
  357.                     reg = '(?:.*)' + rest
  358.             elif include_names:
  359.                 reg = '(?P<%s>.*)' % var + rest
  360.             else:
  361.                 reg = '(?:.*)' + rest
  362.             allblank = False
  363.             noreqs = False
  364.         elif part and part[-1] in self.done_chars:
  365.             if allblank:
  366.                 reg = re.escape(part[:-1]) + '(' + re.escape(part[-1]) + rest
  367.                 reg += ')?'
  368.             else:
  369.                 allblank = False
  370.                 reg = re.escape(part) + rest
  371.         else:
  372.             noreqs = False
  373.             allblank = False
  374.             reg = re.escape(part) + rest
  375.         return (reg, noreqs, allblank)
  376.  
  377.     
  378.     def match(self, url, environ = None, sub_domains = False, sub_domains_ignore = None, domain_match = ''):
  379.         if self.static:
  380.             return False
  381.         match = self.regmatch.match(url)
  382.         if not match:
  383.             return False
  384.         sub_domain = None
  385.         matchdict = match.groupdict()
  386.         result = { }
  387.         extras = self._default_keys - frozenset(matchdict.keys())
  388.         for key, val in matchdict.iteritems():
  389.             if key != 'path_info' and self.encoding:
  390.                 
  391.                 try:
  392.                     if val:
  393.                         pass
  394.                     val = val.decode(self.encoding, self.decode_errors)
  395.                 except UnicodeDecodeError:
  396.                     not sub_domain if self.conditions else sub_domain
  397.                     not sub_domain if self.conditions else sub_domain
  398.                     environ['REQUEST_METHOD'] not in self.conditions['method']
  399.                     return False
  400.                     None if sub_domains and environ and 'HTTP_HOST' in environ else self.static
  401.                 
  402.  
  403.             not sub_domain if self.conditions else sub_domain<EXCEPTION MATCH>UnicodeDecodeError
  404.             if not val and key in self.defaults and self.defaults[key]:
  405.                 result[key] = self.defaults[key]
  406.                 continue
  407.             not sub_domain if self.conditions else sub_domain
  408.             result[key] = val
  409.         
  410.         for key in extras:
  411.             result[key] = self.defaults[key]
  412.         
  413.         if self.conditions and 'function' in self.conditions and not self.conditions['function'](environ, result):
  414.             return False
  415.         return result
  416.  
  417.     
  418.     def generate_non_minimized(self, kargs):
  419.         for k in self.maxkeys - self.minkeys:
  420.             if k not in kargs:
  421.                 return False
  422.             if self.make_unicode(kargs[k]) != self.make_unicode(self.defaults[k]):
  423.                 return False
  424.         
  425.         for arg in self.minkeys:
  426.             if arg not in kargs or kargs[arg] is None:
  427.                 if arg in self.dotkeys:
  428.                     kargs[arg] = ''
  429.                 else:
  430.                     return False
  431.             arg in self.dotkeys
  432.         
  433.         for k in kargs:
  434.             if k in self.maxkeys:
  435.                 if k in self.dotkeys:
  436.                     if kargs[k]:
  437.                         kargs[k] = url_quote('.' + kargs[k], self.encoding)
  438.                     
  439.                 else:
  440.                     kargs[k] = url_quote(kargs[k], self.encoding)
  441.             k in self.dotkeys
  442.         
  443.         return self.regpath % kargs
  444.  
  445.     
  446.     def generate_minimized(self, kargs):
  447.         routelist = self.routebackwards
  448.         urllist = []
  449.         gaps = False
  450.         for part in routelist:
  451.             if isinstance(part, dict) and part['type'] in (':', '.'):
  452.                 arg = part['name']
  453.                 has_arg = kargs.has_key(arg)
  454.                 has_default = self.defaults.has_key(arg)
  455.                 if has_default and not has_arg and not gaps:
  456.                     continue
  457.                 
  458.                 if (has_default or has_arg) and self.make_unicode(kargs[arg]) == self.make_unicode(self.defaults[arg]) and not gaps:
  459.                     continue
  460.                 
  461.                 if has_arg and kargs[arg] is None and has_default and not gaps:
  462.                     continue
  463.                 elif has_arg:
  464.                     val = kargs[arg]
  465.                 elif has_default and self.defaults[arg] is not None:
  466.                     val = self.defaults[arg]
  467.                 elif part['type'] == '.':
  468.                     continue
  469.                 else:
  470.                     return False
  471.                 (self.defaults[arg] is not None).append(url_quote(val, self.encoding))
  472.                 if part['type'] == '.':
  473.                     urllist.append('.')
  474.                 
  475.                 if has_arg:
  476.                     del kargs[arg]
  477.                 
  478.                 gaps = True
  479.                 continue
  480.             if isinstance(part, dict) and part['type'] == '*':
  481.                 arg = part['name']
  482.                 kar = kargs.get(arg)
  483.                 if kar is not None:
  484.                     urllist.append(url_quote(kar, self.encoding))
  485.                     gaps = True
  486.                 
  487.             kar is not None
  488.             if part and part[-1] in self.done_chars:
  489.                 if not gaps and part in self.done_chars:
  490.                     continue
  491.                 elif not gaps:
  492.                     urllist.append(part[:-1])
  493.                     gaps = True
  494.                 else:
  495.                     gaps = True
  496.                     urllist.append(part)
  497.             part in self.done_chars
  498.             gaps = True
  499.             urllist.append(part)
  500.         
  501.         urllist.reverse()
  502.         url = ''.join(urllist)
  503.         return url
  504.  
  505.     
  506.     def generate(self, _ignore_req_list = False, _append_slash = False, **kargs):
  507.         if not _ignore_req_list:
  508.             for key in self.reqs.keys():
  509.                 val = kargs.get(key)
  510.                 if val and not self.req_regs[key].match(self.make_unicode(val)):
  511.                     return False
  512.             
  513.         
  514.         meth = kargs.get('method')
  515.         if meth:
  516.             if self.conditions and 'method' in self.conditions and meth.upper() not in self.conditions['method']:
  517.                 return False
  518.             kargs.pop('method')
  519.         
  520.         if self.minimization:
  521.             url = self.generate_minimized(kargs)
  522.         else:
  523.             url = self.generate_non_minimized(kargs)
  524.         if url is False:
  525.             return url
  526.         if not url.startswith('/') and not (self.static):
  527.             url = '/' + url
  528.         
  529.         extras = frozenset(kargs.keys()) - self.maxkeys
  530.         if extras:
  531.             if _append_slash and not url.endswith('/'):
  532.                 url += '/'
  533.             
  534.             fragments = []
  535.             for key in kargs:
  536.                 if key not in extras:
  537.                     continue
  538.                 
  539.                 if key == 'action' or key == 'controller':
  540.                     continue
  541.                 
  542.                 val = kargs[key]
  543.                 if isinstance(val, (tuple, list)):
  544.                     for value in val:
  545.                         fragments.append((key, _str_encode(value, self.encoding)))
  546.                     
  547.                 fragments.append((key, _str_encode(val, self.encoding)))
  548.             
  549.             if fragments:
  550.                 url += '?'
  551.                 url += urllib.urlencode(fragments)
  552.             
  553.         elif _append_slash and not url.endswith('/'):
  554.             url += '/'
  555.         
  556.         return url
  557.  
  558.  
  559.