code: def route(self,
                path=None,
                method='GET',
                callback=None,
                name=None,
                apply=None,
                skip=None, **config):
          
          if callable(path): path, callback = None, path
          plugins = makelist(apply)
          skiplist = makelist(skip)
  
          def decorator(callback):
              if isinstance(callback, basestring): callback = load(callback)
              for rule in makelist(path) or yieldroutes(callback):
                  for verb in makelist(method):
                      verb = verb.upper()
                      route = Route(self, rule, verb, callback,
                                    name=name,
                                    plugins=plugins,
                                    skiplist=skiplist, **config)
                      self.add_route(route)
              return callback
  
          return decorator(callback) if callback else decorator
docs: A decorator to bind a function to a request URL. Example::
  
                  @app.route('/hello/<name>')
                  def hello(name):
                      return 'Hello %s' % name
  
              The ``<name>`` part is a wildcard. See :class:`Router` for syntax
              details.
  
              :param path: Request path or a list of paths to listen to. If no
                path is specified, it is automatically generated from the
                signature of the function.
              :param method: HTTP method (`GET`, `POST`, `PUT`, ...) or a list of
                methods to listen to. (default: `GET`)
              :param callback: An optional shortcut to avoid the decorator
                syntax. ``route(..., callback=func)`` equals ``route(...)(func)``
              :param name: The name for this route. (default: None)
              :param apply: A decorator or plugin or a list of plugins. These are
                applied to the route callback in addition to installed plugins.
              :param skip: A list of plugins, plugin classes or names. Matching
                plugins are not installed to this route. ``True`` skips all.
  
              Any additional keyword arguments are stored as route-specific
              configuration and passed to plugins (see :meth:`Plugin.apply`).