class ActionDispatch::Routing::RouteSet::Dispatcher

:nodoc:

def call(env) 

def call(env)
  params = env[PARAMETERS_KEY]
  prepare_params!(params)
  # Just raise undefined constant errors if a controller was specified as default.
  unless controller = controller(params, @defaults.key?(:controller))
    return [404, {'X-Cascade' => 'pass'}, []]
  end
  dispatch(controller, params[:action], env)
end

def controller(params, default_controller=true)

controller, it means we should respect the @scope[:module] parameter.
delegate the control back to Rack cascade. Besides, if this is not a default
segment, as in :controller(/:action), we should simply return nil and
a user error. However, if the controller was retrieved through a dynamic
we should raise an error in case it's not found, because it usually means
If this is a default_controller (i.e. a controller specified by the user) 
def controller(params, default_controller=true)
  if params && params.key?(:controller)
    controller_param = params[:controller]
    controller_reference(controller_param)
  end
rescue NameError => e
  raise ActionController::RoutingError, e.message, e.backtrace if default_controller
end

def controller_reference(controller_param) 

def controller_reference(controller_param)
  controller_name = "#{controller_param.camelize}Controller"
  unless controller = @controllers[controller_param]
    controller = @controllers[controller_param] =
      ActiveSupport::Dependencies.reference(controller_name)
  end
  controller.get(controller_name)
end

def dispatch(controller, action, env) 

def dispatch(controller, action, env)
  controller.action(action).call(env)
end

def initialize(options={})

:nodoc: 
def initialize(options={})
  @defaults = options[:defaults]
  @glob_param = options.delete(:glob)
  @controllers = {}
end

def merge_default_action!(params) 

def merge_default_action!(params)
  params[:action] ||= 'index'
end

def normalize_controller!(params) 

def normalize_controller!(params)
  params[:controller] = params[:controller].underscore if params.key?(:controller)
end

def prepare_params!(params) 

def prepare_params!(params)
  normalize_controller!(params)
  merge_default_action!(params)
  split_glob_param!(params) if @glob_param
end

def split_glob_param!(params) 

def split_glob_param!(params)
  params[@glob_param] = params[@glob_param].split('/').map { |v| URI.parser.unescape(v) }
end