Add a new url route.

        Args:
            See flask.Flask.add_url_route().
966318
def add_url_rule(self, route, endpoint, handler):
        
        self.app.add_url_rule(route, endpoint, handler)
703435
def add_urlhelpers(event):
    
    event['static_url'] = lambda x: static_path(x, event['request'])
    event['route_url'] = lambda name, *args, **kwargs: \
        route_path(name, event['request'], *args, **kwargs)
    event['parse_rest'] = parse_rest
    event['has_permission'] = event['request'].has_permission
964263
def add_url(url, params = {})
      page = Page.new(url, params)
      yield(page) if block_given?
      internal_queue << page.to_json
    end
347987
def add_request(self, request):
        

        # Duplicate request name?
        if request.name in self.requests:
            raise ValueError('redefinition of request "{0}"'.format(request.name))
        self.requests[request.name] = request

        # Add the request URLs
        for method, url in request.urls:

            # URL with arguments?
            if RE_URL_ARG.search(url):
                request_regex = '^' + RE_URL_ARG_ESC.sub(r'/(?P<\1>[^/]+)', re.escape(url)) + '$'
                self.__request_regex.append((method, re.compile(request_regex), request))
            else:
                request_key = (method, url)
                if request_key in self.__request_urls:
                    raise ValueError('redefinition of request URL "{0}"'.format(url))
                self.__request_urls[request_key] = request
1018885
def add_url (self, url, line=0, column=0, page=0, name=u"", base=None):
        """"""
        if base:
            base_ref = urlutil.url_norm(base)[0]
        else:
            base_ref = None
        url_data = get_url_from(url, self.recursion_level+1, self.aggregate,
            parent_url=self.url, base_ref=base_ref, line=line, column=column,
            page=page, name=name, parent_content_type=self.content_type)
        self.aggregate.urlqueue.put(url_data)
993886
def add_patch(self, path: str, handler: _WebHandler,
                  **kwargs: Any) -> AbstractRoute:
        
        return self.add_route(hdrs.METH_PATCH, path, handler, **kwargs)
45008
def dispatch_url(self, url_string):
        
        url, url_adapter, query_args = self.parse_url(url_string)

        try:
            endpoint, kwargs = url_adapter.match()
        except NotFound:
            raise NotSupported(url_string)
        except RequestRedirect as e:
            new_url = "{0.new_url}?{1}".format(e, url_encode(query_args))
            return self.dispatch_url(new_url)

        try:
            handler = import_string(endpoint)
            request = Request(url=url, args=query_args)
            return handler(request, **kwargs)
        except RequestRedirect as e:
            return self.dispatch_url(e.new_url)
1120759
def add_patch(self, *args, **kwargs):
        
        return self.add_route(hdrs.METH_PATCH, *args, **kwargs)
635911
def add_one(self, url: str,
                url_properties: Optional[URLProperties]=None,
                url_data: Optional[URLData]=None):
        '''
        '''
        self.add_many([AddURLInfo(url, url_properties, url_data)])
1293895
def add_head(self, path: str, handler: _WebHandler,
                 **kwargs: Any) -> AbstractRoute:
        
        return self.add_route(hdrs.METH_HEAD, path, handler, **kwargs)
444933
def add_subroute(self, pattern: str) -> "URLDispatcher":
        
        return URLDispatcher(
            urlmapper=self.urlmapper,
            prefix=self.prefix + pattern,
            applications=self.applications,
            extra_environ=self.extra_environ)
507240
def add_next(self, url, context):
        
        if all([key in context for key in ["redirect_field_name", "redirect_field_value"]]):
            if context["redirect_field_value"]:
                url += "?" + urlencode({
                    context["redirect_field_name"]: context["redirect_field_value"],
                })
        return url
1250151
def add_delete(self, path: str, handler: _WebHandler,
                   **kwargs: Any) -> AbstractRoute:
        
        return self.add_route(hdrs.METH_DELETE, path, handler, **kwargs)
158381
def add_post(self, path: str, handler: _WebHandler,
                 **kwargs: Any) -> AbstractRoute:
        
        return self.add_route(hdrs.METH_POST, path, handler, **kwargs)
605945
def _set_url(self, url):
    
    original_url = self._url
    try:
      self._update_index(url)
    except:
      self._url = original_url
      raise
1260363
def insert_route(**kw):
    
    binding = {
            'path': None,
            'node_id': None,
            'weight': None,
            'method': "GET"
            }
    binding.update(kw)
    with current_app.app_context():
        db.execute(text(fetch_query_string('insert_route.sql')), **binding)
441258
def _add_route(self, method, path, middleware=None):
        """"""
        if middleware is not None:
            self.add(method, path, middleware)
            return self
        else:
            # return a lambda that will return the 'func' argument
            return lambda func: (
                self.add(method, path, func),
                func
            )[1]