dancer::route::cache(3pm) [debian man page]

Dancer::Route::Cache(3pm)				User Contributed Perl Documentation				 Dancer::Route::Cache(3pm)

NAME

       Dancer::Route::Cache - route caching mechanism for Dancer

SYNOPSIS

	   my $cache = Dancer::Route::Cache->new(
	       path_limit => 300, # optional
	   );

	   # storing a path
	   # /new/item/ is the path, $route is a compiled route
	   $cache->store_path( 'get', '/new/item/', $route );
	   my $cached_route = $cache->route_from_path('/new/item/');

DESCRIPTION

       When Dancer first starts, it has to compile a regexp list of all the routes.  Then, on each request it goes over the compiled routes list
       and tries to compare the requested path to a route.

       A major drawback is that Dancer has to go over the matching on every request, which (especially on CGI-based applications) can be very time
       consuming.

       The caching mechanism allows one to cache some requests to specific routes (but NOT specific results) and run those routes on a specific
       path. This allows us to speed up Dancer quite a lot.

METHODS
/SUBROUTINES
   new(@args)
       Creates a new route cache object.

	   my $cache = Dancer::Route::Cache->new(
	       path_limit => 100,   # only 100 paths will be cached
	       size_limit => '30M', # max size for cache is 30MB
	   );

       Please check the "ATTRIBUTES" section below to learn about the arguments for "new()".

   route_from_path($path)
       Fetches the route from the path in the cache.

   store_path( $method, $path => $route )
       Stores the route in the cache according to the path and $method.

       For developers: the reason we're using an object for this and not directly using the registry hash is because we need to enforce the
       limits.

   parse_size($size)
       Parses the size wanted to bytes. It can handle Kilobytes, Megabytes or Gigabytes.

       NOTICE: handles bytes, not bits!

	   my $bytes = $cache->parse_size('30M');

	   # doesn't need an existing object
	   $bytes = Dancer::Route::Cache->parse_size('300G'); # works this way too

   route_cache_size
       Returns a rough calculation the size of the cache. This is used to enforce the size limit.

   route_cache_paths
       Returns all the paths in the cache. This is used to enforce the path limit.

ATTRIBUTES

   size_limit($limit)
       Allows one to set a size limit of the cache.

       Returns the limit (post-set).

	   $cache->size_limit('10K');	   # sets limit
	   my $limit = $cache->size_limit; # gets limit

   path_limit($limit)
       A path limit. That is, the amount of paths that whose routes will be cached.

       Returns the limit (post-set).

	   $cache->path_limit('100');	   # sets limit
	   my $limit = $cache->path_limit; # gets limit

AUTHOR

       Sawyer X

LICENSE AND COPYRIGHT

       Copyright 2010 Sawyer X.

       This program is free software; you can redistribute it and/or modify it under the terms of either: the GNU General Public License as
       published by the Free Software Foundation; or the Artistic License.

       See http://dev.perl.org/licenses/ for more information.

perl v5.14.2							    2012-01-27						 Dancer::Route::Cache(3pm)

Mojolicious::Routes(3pm)				User Contributed Perl Documentation				  Mojolicious::Routes(3pm)

NAME

       Mojolicious::Routes - Always find your destination with routes

SYNOPSIS

	 use Mojolicious::Routes;

	 # New routes tree
	 my $r = Mojolicious::Routes->new;

	 # Normal route matching "/articles" with parameters "controller" and
	 # "action"
	 $r->route('/articles')->to(controller => 'article', action => 'list');

	 # Route with a placeholder matching everything but "/" and "."
	 $r->route('/:controller')->to(action => 'list');

	 # Route with a placeholder and regex constraint
	 $r->route('/articles/:id', id => qr/d+/)
	   ->to(controller => 'article', action => 'view');

	 # Route with an optional parameter "year"
	 $r->route('/archive/:year')
	   ->to(controller => 'archive', action => 'list', year => undef);

	 # Nested route for two actions sharing the same "controller" parameter
	 my $books = $r->route('/books/:id')->to(controller => 'book');
	 $books->route('/edit')->to(action => 'edit');
	 $books->route('/delete')->to(action => 'delete');

	 # Bridges can be used to chain multiple routes
	 $r->bridge->to(controller => 'foo', action =>'auth')
	   ->route('/blog')->to(action => 'list');

	 # Simplified Mojolicious::Lite style route generation is also possible
	 $r->get('/')->to(controller => 'blog', action => 'welcome');
	 my $blog = $r->under('/blog');
	 $blog->post('/list')->to('blog#list');
	 $blog->get(sub { shift->render(text => 'Go away!') });

DESCRIPTION

       Mojolicious::Routes is the core of the Mojolicious web framework.

       See Mojolicious::Guides::Routing for more.

ATTRIBUTES

       Mojolicious::Routes inherits all attributes from Mojolicious::Routes::Route and implements the following new ones.

   "base_classes"
	 my $classes = $r->base_classes;
	 $r	     = $r->base_classes(['MyApp::Controller']);

       Base classes used to identify controllers, defaults to Mojolicious::Controller and Mojo.

   "cache"
	 my $cache = $r->cache;
	 $r	   = $r->cache(Mojo::Cache->new);

       Routing cache, defaults to a Mojo::Cache object.

	 # Disable caching
	 $r->cache(0);

   "conditions"
	 my $conditions = $r->conditions;
	 $r		= $r->conditions({foo => sub {...}});

       Contains all available conditions.

   "hidden"
	 my $hidden = $r->hidden;
	 $r	    = $r->hidden([qw(attr has new)]);

       Controller methods and attributes that are hidden from routes, defaults to "attr", "has" and "new".

   "namespace"
	 my $namespace = $r->namespace;
	 $r	       = $r->namespace('Foo::Bar::Controller');

       Namespace used by "dispatch" to search for controllers.

   "shortcuts"
	 my $shortcuts = $r->shortcuts;
	 $r	       = $r->shortcuts({foo => sub {...}});

       Contains all available shortcuts.

METHODS

       Mojolicious::Routes inherits all methods from Mojolicious::Routes::Route and implements the following ones.

   "add_condition"
	 $r = $r->add_condition(foo => sub {...});

       Add a new condition.

   "add_shortcut"
	 $r = $r->add_shortcut(foo => sub {...});

       Add a new shortcut.

   "auto_render"
	 $r->auto_render(Mojolicious::Controller->new);

       Automatic rendering.

   "dispatch"
	 my $success = $r->dispatch(Mojolicious::Controller->new);

       Match routes with Mojolicious::Routes::Match and dispatch.

   "hide"
	 $r = $r->hide(qw(foo bar));

       Hide controller methods and attributes from routes.

   "route"
	 my $route = $r->route;
	 my $route = $r->route('/:action');
	 my $route = $r->route('/:action', action => qr/w+/);
	 my $route = $r->route(format => 0);

       Generate route matching all HTTP request methods.

SEE ALSO

       Mojolicious, Mojolicious::Guides, <http://mojolicio.us>.

perl v5.14.2							    2012-09-05						  Mojolicious::Routes(3pm)