Class: ActionController::Routing::Route

Inherits:
Object
  • Object
show all
Defined in:
lib/action_controller/routing.rb

Overview

:nodoc:

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Route

Returns a new instance of Route.



354
355
356
357
358
359
 
# File 'lib/action_controller/routing.rb', line 354

def initialize
  @segments = []
  @requirements = {}
  @conditions = {}
  @optimise = true
end

Instance Attribute Details

#conditions ⇒ Object

Returns the value of attribute conditions.



352
353
354
 
# File 'lib/action_controller/routing.rb', line 352

def conditions
  @conditions
end

#optimise ⇒ Object

Returns the value of attribute optimise.



352
353
354
 
# File 'lib/action_controller/routing.rb', line 352

def optimise
  @optimise
end

#requirements ⇒ Object

Returns the value of attribute requirements.



352
353
354
 
# File 'lib/action_controller/routing.rb', line 352

def requirements
  @requirements
end

#segments ⇒ Object

Returns the value of attribute segments.



352
353
354
 
# File 'lib/action_controller/routing.rb', line 352

def segments
  @segments
end

Instance Method Details

#append_query_string(path, hash, query_keys = nil) ⇒ Object

Generate the query string with any extra keys in the hash and append it to the given path, returning the new path.



480
481
482
483
484
 
# File 'lib/action_controller/routing.rb', line 480

def append_query_string(path, hash, query_keys=nil)
  return nil unless path
  query_keys ||= extra_keys(hash)
  "#{path}#{build_query_string(hash, query_keys)}"
end

#build_query_string(hash, only_keys = nil) ⇒ Object

Build a query string from the keys of the given hash. If only_keys is given (as an array), only the keys indicated will be used to build the query string. The query string will correctly build array parameter values.



500
501
502
503
504
505
506
507
508
509
510
 
# File 'lib/action_controller/routing.rb', line 500

def build_query_string(hash, only_keys = nil)
  elements = []

  (only_keys || hash.keys).each do |key|
    if value = hash[key]
      elements << value.to_query(key)
    end
  end

  elements.empty? ? '' : "?#{elements.sort * '&'}"
end

#defaults ⇒ Object

Return a hash of key/value pairs representing the keys in the route that have defaults, or which are specified by non-regexp requirements.



546
547
548
549
550
551
552
553
554
555
556
557
 
# File 'lib/action_controller/routing.rb', line 546

def defaults
  @defaults ||= returning({}) do |hash|
    segments.each do |segment|
      next unless segment.respond_to? :default
      hash[segment.key] = segment.default unless segment.default.nil?
    end
    requirements.each do |key,req|
      next if Regexp === req || req.nil?
      hash[key] = req
    end
  end
end

#extra_keys(hash, recall = {}) ⇒ Object

Determine which keys in the given hash are “extra”. Extra keys are those that were not used to generate a particular route. The extra keys also do not include those recalled from the prior request, nor do they include any keys that were implied in the route (like a :controller that is required, but not explicitly used in the text of the route.)



492
493
494
 
# File 'lib/action_controller/routing.rb', line 492

def extra_keys(hash, recall={})
  (hash || {}).keys.map { |k| k.to_sym } - (recall || {}).keys - significant_keys
end

#generate(options, hash, expire_on = {}) ⇒ Object

Write the real generation implementation and then resend the message.



468
469
470
471
 
# File 'lib/action_controller/routing.rb', line 468

def generate(options, hash, expire_on = {})
  write_generation
  generate options, hash, expire_on
end

#generate_extras(options, hash, expire_on = {}) ⇒ Object 



473
474
475
476
 
# File 'lib/action_controller/routing.rb', line 473

def generate_extras(options, hash, expire_on = {})
  write_generation
  generate_extras options, hash, expire_on
end

#generation_extraction ⇒ Object

Build several lines of code that extract values from the options hash. If any of the values are missing or rejected then a return will be executed.



402
403
404
405
406
 
# File 'lib/action_controller/routing.rb', line 402

def generation_extraction
  segments.collect do |segment|
    segment.extraction_code
  end.compact * "\n"
end

#generation_requirements ⇒ Object

Produce a condition expression that will check the requirements of this route upon generation.



410
411
412
413
414
415
416
417
418
419
420
 
# File 'lib/action_controller/routing.rb', line 410

def generation_requirements
  requirement_conditions = requirements.collect do |key, req|
    if req.is_a? Regexp
      value_regexp = Regexp.new "\\A#{req.source}\\Z"
      "hash[:#{key}] && #{value_regexp.inspect} =~ options[:#{key}]"
    else
      "hash[:#{key}] == #{req.inspect}"
    end
  end
  requirement_conditions * ' && ' unless requirement_conditions.empty?
end

#generation_structure ⇒ Object 



422
423
424
 
# File 'lib/action_controller/routing.rb', line 422

def generation_structure
  segments.last.string_structure segments[0..-2]
end

#matches_controller_and_action?(controller, action) ⇒ Boolean

Returns:

  • (Boolean) 


559
560
561
562
563
564
565
566
567
568
 
# File 'lib/action_controller/routing.rb', line 559

def matches_controller_and_action?(controller, action)
  unless defined? @matching_prepared
    @controller_requirement = requirement_for(:controller)
    @action_requirement = requirement_for(:action)
    @matching_prepared = true
  end

  (@controller_requirement.nil? || @controller_requirement === controller) &&
  (@action_requirement.nil? || @action_requirement === action)
end

#optimise? ⇒ Boolean

Indicates whether the routes should be optimised with the string interpolation version of the named routes methods.

Returns:

  • (Boolean) 


363
364
365
 
# File 'lib/action_controller/routing.rb', line 363

def optimise?
  @optimise && ActionController::Base::optimise_named_routes
end

#parameter_shell ⇒ Object

A route’s parameter shell contains parameter values that are not in the route’s path, but should be placed in the recognized hash.

For example, +=> ‘pages’, :action => ‘show’ is the shell for the route:

map.connect '/page/:id', :controller => 'pages', :action => 'show', :id => /\d+/



525
526
527
528
529
530
531
 
# File 'lib/action_controller/routing.rb', line 525

def parameter_shell
  @parameter_shell ||= returning({}) do |shell|
    requirements.each do |key, requirement|
      shell[key] = requirement unless requirement.is_a? Regexp
    end
  end
end

#recognition_conditions ⇒ Object

Plugins may override this method to add other conditions, like checks on host, subdomain, and so forth. Note that changes here only affect route recognition, not generation.



441
442
443
444
445
 
# File 'lib/action_controller/routing.rb', line 441

def recognition_conditions
  result = ["(match = #{Regexp.new(recognition_pattern).inspect}.match(path))"]
  result << "conditions[:method] === env[:method]" if conditions[:method]
  result
end

#recognition_extraction ⇒ Object

Write the code to extract the parameters from a matched route.



457
458
459
460
461
462
463
464
465
 
# File 'lib/action_controller/routing.rb', line 457

def recognition_extraction
  next_capture = 1
  extraction = segments.collect do |segment|
    x = segment.match_extraction(next_capture)
    next_capture += Regexp.new(segment.regexp_chunk).number_of_captures
    x
  end
  extraction.compact
end

#recognition_pattern(wrap = true) ⇒ Object

Build the regular expression pattern that will match this route.



448
449
450
451
452
453
454
 
# File 'lib/action_controller/routing.rb', line 448

def recognition_pattern(wrap = true)
  pattern = ''
  segments.reverse_each do |segment|
    pattern = segment.build_pattern pattern
  end
  wrap ? ("\\A" + pattern + "\\Z") : pattern
end

#recognize(path, environment = {}) ⇒ Object

Write the real recognition implementation and then resend the message.



513
514
515
516
 
# File 'lib/action_controller/routing.rb', line 513

def recognize(path, environment={})
  write_recognition
  recognize path, environment
end

#segment_keys ⇒ Object 



367
368
369
370
371
 
# File 'lib/action_controller/routing.rb', line 367

def segment_keys
  segments.collect do |segment|
    segment.key if segment.respond_to? :key
  end.compact
end

#significant_keys ⇒ Object

Return an array containing all the keys that are used in this route. This includes keys that appear inside the path, and keys that have requirements placed upon them.



536
537
538
539
540
541
542
 
# File 'lib/action_controller/routing.rb', line 536

def significant_keys
  @significant_keys ||= returning [] do |sk|
    segments.each { |segment| sk << segment.key if segment.respond_to? :key }
    sk.concat requirements.keys
    sk.uniq!
  end
end

#to_s ⇒ Object 



570
571
572
573
574
575
 
# File 'lib/action_controller/routing.rb', line 570

def to_s
  @to_s ||= begin
    segs = segments.inject("") { |str,s| str << s.to_s }
    "%-6s %-40s %s" % [(conditions[:method] || :any).to_s.upcase, segs, requirements.inspect]
  end
end

#write_generation ⇒ Object

Write and compile a generate method for this Route.



374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
 
# File 'lib/action_controller/routing.rb', line 374

def write_generation
  # Build the main body of the generation
  body = "expired = false\n#{generation_extraction}\n#{generation_structure}"

  # If we have conditions that must be tested first, nest the body inside an if
  body = "if #{generation_requirements}\n#{body}\nend" if generation_requirements
  args = "options, hash, expire_on = {}"

  # Nest the body inside of a def block, and then compile it.
  raw_method = method_decl = "def generate_raw(#{args})\npath = begin\n#{body}\nend\n[path, hash]\nend"
  instance_eval method_decl, "generated code (#{__FILE__}:#{__LINE__})"

  # expire_on.keys == recall.keys; in other words, the keys in the expire_on hash
  # are the same as the keys that were recalled from the previous request. Thus,
  # we can use the expire_on.keys to determine which keys ought to be used to build
  # the query string. (Never use keys from the recalled request when building the
  # query string.)

  method_decl = "def generate(#{args})\npath, hash = generate_raw(options, hash, expire_on)\nappend_query_string(path, hash, extra_keys(options))\nend"
  instance_eval method_decl, "generated code (#{__FILE__}:#{__LINE__})"

  method_decl = "def generate_extras(#{args})\npath, hash = generate_raw(options, hash, expire_on)\n[path, extra_keys(options)]\nend"
  instance_eval method_decl, "generated code (#{__FILE__}:#{__LINE__})"
  raw_method
end

#write_recognition ⇒ Object

Write and compile a recognize method for this Route.



427
428
429
430
431
432
433
434
435
436
 
# File 'lib/action_controller/routing.rb', line 427

def write_recognition
  # Create an if structure to extract the params from a match if it occurs.
  body = "params = parameter_shell.dup\n#{recognition_extraction * "\n"}\nparams"
  body = "if #{recognition_conditions.join(" && ")}\n#{body}\nend"

  # Build the method declaration and compile it
  method_decl = "def recognize(path, env={})\n#{body}\nend"
  instance_eval method_decl, "generated code (#{__FILE__}:#{__LINE__})"
  method_decl
end