Class Merb::Router::Behavior
In: lib/merb-core/dispatch/router/behavior.rb
Parent: Object

The Behavior class is an interim route-building class that ties pattern-matching conditions to output parameters, params.

Methods

Attributes

conditions  [R] 
params  [R] 
parent  [RW] 
placeholders  [R] 

Public Class methods

Parameters

arr<Array>:The array to convert to a code string.

Returns

String:The arr‘s elements converted to string and joined with " + ", with any string elements surrounded by quotes.

Parameters

string1<String>:The string to concatenate with.
string2<String>:The string to concatenate.

Returns

String:the concatenated string with regexp end caps removed.

Parameters

string<String>:The string in which to count parentheses.
pos<Fixnum>:The last character for counting.

Returns

Fixnum:The number of open parentheses in string, up to and including pos.

Parameters

conditions<Hash>:Conditions to be met for this behavior to take effect.
params<Hash>:Hash describing the course action to take (Behavior) when the conditions match. The values of the params keys must be Strings.
parent<Behavior, Nil>:The parent of this Behavior. Defaults to nil.

Public Instance methods

Register a new route.

Parameters

path<String, Regex>:The url path to match
params<Hash>:The parameters the new routes maps to.

Returns

Route:The resulting Route.

Creates the most common routes /:controller/:action/:id.format when called with no arguments. You can pass a hash or a block to add parameters or override the default behavior.

Parameters

params<Hash>:This optional hash can be used to augment the default settings
&block:When passing a block a new behavior is yielded and more refinement is possible.

Returns

Route:the default route

Examples

  # Passing an extra parameter "mode" to all matches
  r.default_routes :mode => "default"

  # specifying exceptions within a block
  r.default_routes do |nr|
    nr.defer_to do |request, params|
      nr.match(:protocol => "http://").to(:controller => "login",
        :action => "new") if request.env["REQUEST_URI"] =~ /\/private\//
    end
  end

Takes a block and stores it for deferred conditional routes. The block takes the request object and the params hash as parameters.

Parameters

params<Hash>:Parameters and conditions associated with this behavior.
&conditional_block:A block with the conditions to be met for the behavior to take effect.

Returns

Route :The default route.

Examples

  r.defer_to do |request, params|
    params.merge :controller => 'here',
      :action => 'there' if request.xhr?
  end

Returns

String:A human readable form of the behavior.

Matches a path and any number of optional request methods as conditions of a route. Alternatively, path can be a hash of conditions, in which case conditions ignored.

Parameters

path<String, Regexp>:When passing a string as path you‘re defining a literal definition for your route. Using a colon, ex.: ":login", defines both a capture and a named param. When passing a regular expression you can define captures explicitly within the regular expression syntax. path is optional.
conditions<Hash>:This optional hash helps refine the settings for the route. When combined with a block it can help keep your routes DRY
&block:Passes a new instance of a Behavior object into the optional block so that sub-matching and routes nesting may occur.

Returns

Behavior:A new instance of Behavior with the specified path and conditions.

Tip: When nesting always make sure the most inner sub-match registers a Route and doesn‘t just returns new Behaviors.

Examples

  # registers /foo/bar to controller => "foo", :action => "bar"
  # and /foo/baz to controller => "foo", :action => "caz"
  r.match "/foo", :controller => "foo" do |f|
    f.match("/bar").to(:action => "bar")
    f.match("/baz").to(:action => "caz")
  end

  r.match "/foo", :controller => "foo" do |f|
    f.match("/bar", :action => "bar")
    f.match("/baz", :action => "caz")
  end # => doesn't register any routes at all

  # match also takes regular expressions
  r.match(%r[/account/([a-z]{4,6})]).to(:controller => "account",
     :action => "show", :id => "[1]")

Generates a new child behavior without the path if the path matches an empty string. Yields the new behavior to a block.

Parameters

conditions<Hash>:Optional conditions to pass to the new route.

Block parameters

new_behavior<Behavior>:The child behavior.

Returns

Behavior:The new behavior.

Returns

Hash:The conditions of this behavior merged with the conditions of all its ancestors.

Returns

Hash:The original conditions of this behavior merged with the original conditions of all its ancestors.

Returns

Hash:The params of this behavior merged with the params of all its ancestors.

Returns

Hash:The route placeholders, e.g. :controllers, of this behavior merged with the placeholders of all its ancestors.

Creates a namespace for a route. This way you can have logical separation to your routes.

Parameters

name_or_path<String, Symbol>:The name or path of the namespace.
options<Hash>:Optional hash, set :path if you want to override what appears on the url
&block:A new Behavior instance is yielded in the block for nested resources.

Block parameters

r<Behavior>:The namespace behavior object.

Examples

  r.namespace :admin do |admin|
    admin.resources :accounts
    admin.resource :email
  end

  # /super_admin/accounts
  r.namespace(:admin, :path=>"super_admin") do |admin|
    admin.resources :accounts
  end

Returns

Boolean:True if this behavior has a regexp.

Behavior#resource is a route helper for defining a singular RESTful resource. It yields to a block for child routes.

Parameters

name<String, Symbol>:The name of the resource.
options<Hash>:Overides and parameters to be associated with the route.

Options (options)

:namespace<~to_s>: The namespace for this route. :name_prefix<~to_s>:

  A prefix for the named routes. If a namespace is passed and there
  isn't a name prefix, the namespace will become the prefix.

:controller<~to_s>: The controller for this route

Block parameters

next_level<Behavior>:The child behavior.

Returns

Array:Routes which define a RESTful single resource.

Examples

 r.resources :account # will result in the typical RESTful CRUD
   # GET     /account/new                :action => "new"
   # POST    /account/?(\.:format)?,     :action => "create"
   # GET     /account/(\.:format)?       :action => "show"
   # GET     /account/[;/]edit           :action => "edit"
   # PUT     /account/(\.:format)?       :action => "update"
   # GET     /account/[;/]delete         :action => "delete"
   # DELETE  /account/(\.:format)?       :action => "destroy"

You can optionally pass :namespace and :controller to refine the routing or pass a block to nest resources.

  r.resource :account, :namespace => "admin" do |account|
    account.resources :preferences, :controller => "settings"
  end

@public

Behavior#resources is a route helper for defining a collection of RESTful resources. It yields to a block for child routes.

Parameters

name<String, Symbol>:The name of the resources
options<Hash>:Ovverides and parameters to be associated with the route

Options (options)

:namespace<~to_s>: The namespace for this route. :name_prefix<~to_s>:

  A prefix for the named routes. If a namespace is passed and there
  isn't a name prefix, the namespace will become the prefix.

:controller<~to_s>: The controller for this route :collection<~to_s>: Special settings for the collections routes :member<Hash>:

  Special settings and resources related to a specific member of this
  resource.

:keys<Array>:

  A list of the keys to be used instead of :id with the resource in the order of the url.

Block parameters

next_level<Behavior>:The child behavior.

Returns

Array:Routes which will define the specified RESTful collection of resources

Examples

 r.resources :posts # will result in the typical RESTful CRUD
   # GET     /posts/?(\.:format)?      :action => "index"
   # GET     /posts/index(\.:format)?  :action => "index"
   # GET     /posts/new                :action => "new"
   # POST    /posts/?(\.:format)?,     :action => "create"
   # GET     /posts/:id(\.:format)?    :action => "show"
   # GET     /posts/:id[;/]edit        :action => "edit"
   # PUT     /posts/:id(\.:format)?    :action => "update"
   # GET     /posts/:id[;/]delete      :action => "delete"
   # DELETE  /posts/:id(\.:format)?    :action => "destroy"

 # Nesting resources
 r.resources :posts do |posts|
   posts.resources :comments
 end

Creates a Route from one or more Behavior objects, unless a block is passed in.

Parameters

params<Hash>:The parameters the route maps to.
&block:Optional block. A new Behavior object is yielded and further to operations may be called in the block.

Block parameters

new_behavior<Behavior>:The child behavior.

Returns

Route:It registers a new route and returns it.

Examples

  r.match('/:controller/:id).to(:action => 'show')

  r.to :controller => 'simple' do |s|
    s.match('/test').to(:action => 'index')
    s.match('/other').to(:action => 'other')
  end

Parameters

params<Hash>:Optional params for generating the RESTful routes.
&block:Optional block for the route generation.

Returns

Array:Routes matching the RESTful singular resource.

Parameters

params<Hash>:Optional params for generating the RESTful routes.
&block:Optional block for the route generation.

Returns

Array:Routes matching the RESTful resource.

Parameters

params<Hash>:Optional additional parameters for generating the route.
&conditional_block:A conditional block to be passed to Route.new.

Returns

Route:A new route based on this behavior.

Protected Instance methods

Parameters

list<Array>:A list to which the ancestors should be added.

Returns

Array:All the ancestor behaviors of this behavior.

Parameters

conditions<Hash>:The conditions to compile. Defaults to merged_conditions.

Returns

Hash:The compiled conditions, with each value as a Regexp object.

Parameters

params<Hash>:The params to compile. Defaults to merged_params.
placeholders<Hash>:The route placeholders for this behavior. Defaults to merged_placeholders.

Returns

String:The params hash in an eval‘able form.

Examples

  compiled_params({ :controller => "admin/:controller" })
    # => { :controller => "'admin/' + matches[:path][1]" }

Store the conditions as original conditions.

Calculate the behaviors from the conditions and store them.

Parameters

behaviors<Array>:The behaviors to create routes from.
params<Hash>:Optional params for the route generation.
&conditional_block:Optional block for the route generation.

Returns

Array:The routes matching the behaviors.

Parameters

name_or_path<~to_s>:The name or path to convert to a form suitable for a prefix.

Returns

String:The prefix.

Returns

Fixnum:Number of regexp captures in the :path condition.

Parameters

parent<Merb::Router::Behavior>:The parent behavior for the generated resource behaviors.

Returns

Array:Behaviors for a singular RESTful resource.

Parameters

matched_keys<String>:The keys to match

Returns

Array:Behaviors for a RESTful resource.

Convert conditions to regular expression string sources for consistency.

Returns

Fixnum:Total number of previous path captures.

[Validate]