def _resolve(self, raw_path): # Tokenize path path = tokenize_path(raw_path) node = control.root_controller() cls = node log.debug('resolving %s (%r) on tree %r', raw_path, path, node) # Check root if node is None: return wrap_exc_in_callable(http.ControllerNotFound('No root controller exists')) # Special case: empty path == root.__call__ if not path: try: node = node().__call__ log.debug('found leaf: %s', node) return node except AttributeError: return wrap_exc_in_callable(http.MethodNotFound('/')) # Traverse tree for part in path: log.debug('looking at part %r', part) found = None # 1. Search subclasses first log.debug('matching %r to subclasses of %r', part, node) try: subclasses = node.__subclasses__() except AttributeError: log.debug('node %r does not have subclasses -- returning MethodNotFound') return wrap_exc_in_callable(http.MethodNotFound(raw_path)) for subclass in node.__subclasses__(): if _node_name(subclass, subclass.controller_name()) == part: if getattr(subclass, 'hidden', False): continue found = subclass break if found is not None: node = found cls = node continue # 2. Search methods log.debug('matching %r to methods of %r', part, node) # Aquire instance if type(node) is type: node = node() for k,v in node.__dict__.items(): if _node_name(v, k.lower()) == part: # If the leaf is hidden, we skip it if getattr(v, 'hidden', False): continue # If the leaf is not defined directly on parent node node, and # node.delegate evaluates to False, we bail out if not control.leaf_is_visible(v, cls): node = None else: found = v break # Check found node if found is not None: node = found node_type = type(node) # The following two lines enables accepting prefix routes: #if node_type is MethodType or node_type is FunctionType: # break else: # Not found return wrap_exc_in_callable(http.MethodNotFound(raw_path)) # Did we hit a class/type at the end? If so, get its instance. if type(node) is type: try: cls = node node = cls().__call__ if not control.leaf_is_visible(node, cls): node = None except AttributeError: # Uncallable leaf node = None # Not callable? if node is None or not callable(node): return wrap_exc_in_callable(http.MethodNotFound(raw_path)) log.debug('found leaf: %s', node) return node
def _get_template(node): tpl = getattr(node, "template", None) if tpl is not None: if not isinstance(tpl, list): tpl = tokenize_path(str(tpl)) return tpl