def reverse_werkzeug_url(url, values):
    rule = Rule(url)
    # Rule needs to be bound before building
    m = RuleMap([rule])
    # Note: this seems to be changing in Werkzeug master
    domain_part, url = rule.build(values)
    return url

    def __init__(self, *args, **kwargs):
        """
        :param view_func: a view function.
        """
        # Setup OPTIONS parameter
        methods = kwargs.pop("methods", ("GET",))
        provide_automatic_options = False
        if "OPTIONS" not in methods:
            methods = tuple(methods) + ("OPTIONS",)
            provide_automatic_options = True
        kwargs["methods"] = methods
        self.provide_automatic_options = provide_automatic_options

        # Set the view function
        endpoint = kwargs.get("endpoint", None)
        view_func = kwargs.pop("view_func", None)
        if not view_func:
            if callable(endpoint):
                view_func = endpoint
                endpoint = endpoint.__name__
            elif type(endpoint) is str:
                view_func = import_string(endpoint)

        self.view_func = view_func
        kwargs["endpoint"] = endpoint
        RuleBase.__init__(self, *args, **kwargs)

		def define_routes(cls):
			for route in cls.routes:
				rule = Rule(cls.endpoint + route['route'], endpoint=cls.endpoint + '/' + route['view_function'], methods=route['methods'], strict_slashes=False)
				rule.route = route

				app.view_functions[cls.endpoint + '/' + route['view_function']] = getattr(cls, route['view_function'])
				app.url_map.add(rule)

			return cls.routes

    def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
        """Connects a URL rule.  Works exactly like the :meth:`route`
        decorator.  If a view_func is provided it will be registered with the
        endpoint.

        Basically this example::

            @app.route('/')
            def index():
                pass

        Is equivalent to the following::

            def index():
                pass
            app.add_url_rule('/', 'index', index)

        If the view_func is not provided you will need to connect the endpoint
        to a view function like so::

            app.view_functions['index'] = index

        .. versionchanged:: 0.2
           `view_func` parameter added.

        .. versionchanged:: 0.6
           `OPTIONS` is added automatically as method.

        :param rule: the URL rule as string
        :param endpoint: the endpoint for the registered URL rule.  Flask
                         itself assumes the name of the view function as
                         endpoint
        :param view_func: the function to call when serving a request to the
                          provided endpoint
        :param options: the options to be forwarded to the underlying
                        :class:`~werkzeug.routing.Rule` object.  A change
                        to Werkzeug is handling of method options.  methods
                        is a list of methods this rule should be limited
                        to (`GET`, `POST` etc.).  By default a rule
                        just listens for `GET` (and implicitly `HEAD`).
                        Starting with Flask 0.6, `OPTIONS` is implicitly
                        added and handled by the standard request handling.
        """
        if endpoint is None:
            endpoint = _endpoint_from_view_func(view_func)
        options['endpoint'] = endpoint
        methods = options.pop('methods', ('GET',))
        provide_automatic_options = False
        if 'OPTIONS' not in methods:
            methods = tuple(methods) + ('OPTIONS',)
            provide_automatic_options = True
        rule = Rule(rule, methods=methods, **options)
        rule.provide_automatic_options = provide_automatic_options
        self.url_map.add(rule)
        if view_func is not None:
            self.view_functions[endpoint] = view_func

def test_rule_emptying():
    """Rule emptying"""
    r = Rule("/foo", {"meh": "muh"}, "x", ["POST"], False, "x", True, None)
    r2 = r.empty()
    assert r.__dict__ == r2.__dict__
    r.methods.add("GET")
    assert r.__dict__ != r2.__dict__
    r.methods.discard("GET")
    r.defaults["meh"] = "aha"
    assert r.__dict__ != r2.__dict__

def test_rule_emptying():
    """Rule emptying"""
    r = Rule('/foo', {'meh': 'muh'}, 'x', ['POST'],
             False, 'x', True, None)
    r2 = r.empty()
    assert r.__dict__ == r2.__dict__
    r.methods.add('GET')
    assert r.__dict__ != r2.__dict__
    r.methods.discard('GET')
    r.defaults['meh'] = 'aha'
    assert r.__dict__ != r2.__dict__

 def __init__(self, string, defaults=None, subdomain=None, methods=None,
              build_only=False, endpoint=None, strict_slashes=None,
              redirect_to=None, permission=None, template=None, func=None,
              authRequired=False, expires=None, mimetype=None, nocache=False):
     Rule.__init__(self, string, defaults, subdomain, methods, build_only,
                   endpoint, strict_slashes, redirect_to)
     self.permission = permission
     self.template = template
     self.func = func
     self.authRequired = authRequired
     self.expires = expires
     self.mimetype = mimetype
     self.nocache = nocache

    def add_url_rule(self, rule, endpoint=None, view_func=None, **options):
        assert view_func is not None, 'view_func is mandatory'
        if endpoint is None:
            endpoint = view_func.__name__
        options['endpoint'] = endpoint
        # supposed to be GET
        methods = set(('GET', ))
        provide_automatic_options = False

        rule = Rule(rule, methods=methods, **options)
        rule.provide_automatic_options = provide_automatic_options
        self.url_map.add(rule)
        if view_func is not None:
            old_func = self.view_functions.get(endpoint)
            if old_func is not None and old_func != view_func:
                raise AssertionError('View function mapping is overwriting an '
                                     'existing endpoint function: %s' % endpoint)
            self.view_functions[endpoint] = view_func

 def match(self, path):
     values = Rule.match(self, path)
     if values is not None:
         values['authRequired'] = self.authRequired
         values['permission'] = self.permission
         values['template'] = self.template
         values['func'] = self.func
         values['expires'] = self.expires
         values['mimetype'] = self.mimetype
         values['nocache'] = self.nocache
     return values

    def __new__(cls, name, bases, attrs):
        # Add a url_map to the class
        url_map = UrlMap(strict_slashes=False)
        # Add a collection of (unbound) view functions
        view_functions = {}
        for base in bases:
            # Extend from url_map of base class
            if hasattr(base, 'url_map') and isinstance(base.url_map, UrlMap):
                for rule in base.url_map.iter_rules():
                    url_map.add(rule.empty())
            # Extend from view_functions of base class
            if hasattr(base, 'view_functions') and isinstance(base.view_functions, dict):
                view_functions.update(base.view_functions)
        for routeattr, route in attrs.items():
            if isinstance(route, _NodeRoute):
                # For wrapped routes, add a rule for each layer of wrapping
                endpoints = []
                while isinstance(route, _NodeRoute):
                    # Save the endpoint name
                    endpoints.append(route.endpoint)
                    # Construct the url rule
                    url_rule = UrlRule(route.rule, endpoint=route.endpoint, methods=route.methods, defaults=route.defaults)
                    url_rule.provide_automatic_options = True
                    url_map.add(url_rule)
                    route = route.f
                # Make a list of endpoints
                for e in endpoints:
                    view_functions[e] = route
                # Restore the original function
                attrs[routeattr] = route
        # Finally, update the URL map and insert it into the class
        url_map.update()
        attrs['url_map'] = url_map
        attrs['view_functions'] = view_functions

        return type.__new__(cls, name, bases, attrs)

 def empty(self):
     new_rule = Rule.empty(self)
     new_rule.gmg_controller = self.gmg_controller
     return new_rule

 def __init__(self, endpoint, url, controller):
     Rule.__init__(self, url, endpoint=endpoint)
     self.gmg_controller = controller

 def __init__(self, string, defaults=None, subdomain=None, methods=None,
              build_only=False, endpoint=None, strict_slashes=None,
              redirect_to=None, alias=False, host=None, mimetype=None):
     _Rule.__init__(self, string, defaults, subdomain, methods, build_only,
                    endpoint, strict_slashes, redirect_to, alias, host)
     self.mimetype = mimetype

 def __init__(self, pattern, **kwargs):
   try:
     self.view = kwargs.pop('view')
   except KeyError:
     self.view = None
   OriginalRule.__init__(self, pattern, **kwargs)

 def __init__(self, endpoint, methods=['get']):
     Rule.__init__(self, '/', endpoint=endpoint, methods=methods)

    def route_(self, rule, methods=None, werkzeug_route=None,
                    tornado_route=None, handler_bases=None, fn=None, nowrap=None):
        if not methods:
            methods = ['GET']

        clsname = '%sHandler' % fn.__name__.capitalize()
        # TODO: things get complicated if you use your own base class and debug=True
        if not handler_bases:
            if self.debug:
                bases = (DebuggableHandler,)
            else:
                bases = (tornado.web.RequestHandler,)
        else:
            bases = (DebuggableHandler,) + handler_bases
        m = {}
        for method in methods:
            inspected = inspect.getargspec(fn)

            can_be_wrapped = True
            if nowrap == None:
                # are we using a tornado.coroutine or something similar,
                # we dont wrap
                if 'tornado' in inspect.getsourcefile(fn):
                    can_be_wrapped = False
                else:
                    can_be_wrapped = nowrap != True
            else:
                can_be_wrapped = nowrap

            self_in_args = inspected.args and inspected.args[0] in ['self', 'handler']

            if not self_in_args and can_be_wrapped==True:
                def wrapper(self, *args, **kwargs):
                    with StackContext(functools.partial(ctx_man, self)) as cm:
                        w = fn #wrap(fn)
                        result = w(*args, **kwargs)

                    if isinstance(result, TemplateProxy):
                        if self._template_engine == 'tornado':
                            self.render(*result.args, **result.kwargs)
                        else:
                            template = self._template_env.get_template(result.args[0])
                            self.finish(template.render(handler=self, **result.kwargs))
                    else:
                        self.finish(result)

                    # import gc
                    # # gc.collect()
                    # print "is gc enabled", gc.isenabled()
                    # print "-----------------"
                    # for obj in gc.get_objects():
                    #     if isinstance(obj, DebuggableHandler):
                    #         print ">>>", type(obj), "<<<"
                    #
                    # print "-----------------"


                m[method.lower()] = wrapper
            else:
                m[method.lower()] = fn

        klass = type(clsname, bases, m)
        klass._template_engine = self.template_engine
        if self.template_engine != 'tornado':
            klass._template_env = self.template_env

        use_werkzeug_route = None

        if tornado_route:
            use_werkzeug_route = False

        if werkzeug_route:
            use_werkzeug_route = True

        if use_werkzeug_route == None:
            use_werkzeug_route = self.is_werkzeug_route(rule)

        if use_werkzeug_route:
            r = Rule(rule, methods=methods)
            self.url_map.add(r)
            r.compile()
            pattern = r._regex.pattern.replace('^\\|', "")
            self.registery[pattern] = klass
        else:
            self.registery[rule] = klass

 def __init__(self, *args, **kwargs):
     self.handler = kwargs.pop('handler', kwargs.get('endpoint', None))
     WerkzeugRule.__init__(self, *args, **kwargs)

	def compile(self):
		Rule.compile(self)
		self._regex = re.compile(self._regex.pattern, 
			re.UNICODE | re.IGNORECASE)

 def __init__(self, endpoint, url, controller, match_slash=True):
     Rule.__init__(self, url, endpoint=endpoint)
     self.gmg_controller = controller
     self.match_slash = match_slash