Rails源代码分析（30）：ActionController::Routing(1)

这个Module穿插在整个ActionPack里面的各个地方，

routing 在启动Rails的同时就会加载：

1.     def initialize_routing
2.       # 确认包含action_controller
3.       return unless configuration.frameworks.include?(:action_controller)
4.       # 加入config加入的controller路径
5.       ActionController::Routing.controller_paths = configuration.controller_paths 
6.       # 加入config加入的route路径
7.       ActionController::Routing::Routes.configuration_file = configuration.routes_configuration_file
8.       ActionController::Routing::Routes.reload
9.     end

Routing分析思路：

1) map.connect (RouteSet, Mapper)

2) add_route (RouteBuilder Route Segment)

类的组合：

Routing

  Helper { include PolymorphicRoutes }

  Routes = RouteSet.new # 主要使用的入口对象

RouteSet

  Mapper

  NamedRouteCollection

  builder = RouteBuilder

  add_route(path, options)

        route = builder.build(path, options)

        routes << route

        route

  

RouteBuilder

  build(path, options)

        route = Route.new

        route.segments = segments

        route.requirements = requirements

        route.conditions = conditions

        ...

        route

这里调用了一个Routes实例,在这里,先看看Routing这个module:

  1) Routing的基本用法

  #

  # The routing module provides URL rewriting in native Ruby. It's a way to

  # redirect incoming requests to controllers and actions. This replaces

  # mod_rewrite rules. Best of all, Rails' Routing works with any web server.

  # Routes are defined in <tt>config/routes.rb</tt>.

  #

  # Consider the following route, installed by Rails when you generate your

  # application:

  #

  #   map.connect ':controller/:action/:id'

  #

  # This route states that it expects requests to consist of a

  # <tt>:controller</tt> followed by an <tt>:action</tt> that in turn is fed

  # some <tt>:id</tt>.

  #

  # Suppose you get an incoming request for <tt>/blog/edit/22</tt>, you'll end up

  # with:

  #

  #   params = { :controller => 'blog',

  #              :action     => 'edit',

  #              :id         => '22'

  #           }

  #

  # Think of creating routes as drawing a map for your requests. The map tells

  # them where to go based on some predefined pattern:

  #

  #   ActionController::Routing::Routes.draw do |map|

  #     Pattern 1 tells some request to go to one place

  #     Pattern 2 tell them to go to another

  #     ...

  #   end

  #

  # The following symbols are special:

  #

  #   :controller maps to your controller name

  #   :action     maps to an action with your controllers

  #

  # Other names simply map to a parameter as in the case of <tt>:id</tt>.

  #

  2） Route 优先级

  #

  # Not all routes are created equally. Routes have priority defined by the

  # order of appearance of the routes in the <tt>config/routes.rb</tt> file. The priority goes

  # from top to bottom. The last route in that file is at the lowest priority

  # and will be applied last. If no route matches, 404 is returned.

  #

  # Within blocks, the empty pattern is at the highest priority.

  # In practice this works out nicely:

  #

  #   ActionController::Routing::Routes.draw do |map|

  #     map.with_options :controller => 'blog' do |blog|

  #       blog.show '',  :action => 'list'

  #     end

  #     map.connect ':controller/:action/:view'

  #   end

  #

  # In this case, invoking blog controller (with an URL like '/blog/')

  # without parameters will activate the 'list' action by default.

  #

  3） 默认的routes和默认的参数

  #

  # Setting a default route is straightforward in Rails - you simply append a

  # Hash at the end of your mapping to set any default parameters.

  #

  # Example:

  #

  #   ActionController::Routing:Routes.draw do |map|

  #     map.connect ':controller/:action/:id', :controller => 'blog'

  #   end

  #

  # This sets up +blog+ as the default controller if no other is specified.

  # This means visiting '/' would invoke the blog controller.

  #

  # More formally, you can define defaults in a route with the <tt>:defaults</tt> key.

  #

  #   map.connect ':controller/:action/:id', :action => 'show', :defaults => { :page => 'Dashboard' }

  #

  # Note: The default routes, as provided by the Rails generator, make all actions in every

  # controller accessible via GET requests. You should consider removing them or commenting

  # them out if you're using named routes and resources.

  #

  4） 命名的 routes

  #

  # Routes can be named with the syntax <tt>map.name_of_route options</tt>,

  # allowing for easy reference within your source as +name_of_route_url+

  # for the full URL and +name_of_route_path+ for the URI path.

  #

  # Example:

  #

  #   # In routes.rb

  #   map.login 'login', :controller => 'accounts', :action => 'login'

  #

  #   # With render, redirect_to, tests, etc.

  #   redirect_to login_url

  #

  # Arguments can be passed as well.

  #

  #   redirect_to show_item_path(:id => 25)

  #

  # Use <tt>map.root</tt> as a shorthand to name a route for the root path "".

  #

  #   # In routes.rb

  #   map.root :controller => 'blogs'

  #

  #   # would recognize http://www.example.com/ as

  #   params = { :controller => 'blogs', :action => 'index' }

  #

  #   # and provide these named routes

  #   root_url   # => 'http://www.example.com/'

  #   root_path  # => ''

  #

  # You can also specify an already-defined named route in your <tt>map.root</tt> call:

  #

  #   # In routes.rb

  #   map.new_session :controller => 'sessions', :action => 'new'

  #   map.root :new_session

  #

  # Note: when using +with_options+, the route is simply named after the

  # method you call on the block parameter rather than map.

  #

  #   # In routes.rb

  #   map.with_options :controller => 'blog' do |blog|

  #     blog.show    '',            :action  => 'list'

  #     blog.delete  'delete/:id',  :action  => 'delete',

  #     blog.edit    'edit/:id',    :action  => 'edit'

  #   end

  #

  #   # provides named routes for show, delete, and edit

  #   link_to @article.title, show_path(:id => @article.id)

  #

  5） 漂亮的 URLs

  #

  # Routes can generate pretty URLs. For example:

  #

  #   map.connect 'articles/:year/:month/:day',

  #               :controller => 'articles',

  #               :action     => 'find_by_date',

  #               :year       => //d{4}/,

  #               :month      => //d{1,2}/,

  #               :day        => //d{1,2}/

  #

  # Using the route above, the URL "http://localhost:3000/articles/2005/11/06"

  # maps to

  #

  #   params = {:year => '2005', :month => '11', :day => '06'}

  #

  6） 参数和正则表达式

  # You can specify a regular expression to define a format for a parameter.

  #

  #   map.geocode 'geocode/:postalcode', :controller => 'geocode',

  #               :action => 'show', :postalcode => //d{5}(-/d{4})?/

  #

  # or, more formally:

  #

  #   map.geocode 'geocode/:postalcode', :controller => 'geocode',

  #               :action => 'show', :requirements => { :postalcode => //d{5}(-/d{4})?/ }

  #

  # Formats can include the 'ignorecase' and 'extended syntax' regular

  # expression modifiers:

  #

  #   map.geocode 'geocode/:postalcode', :controller => 'geocode',

  #               :action => 'show', :postalcode => /hx/d/d/s/d[a-z]{2}/i

  #

  #   map.geocode 'geocode/:postalcode', :controller => 'geocode',

  #               :action => 'show',:requirements => {

  #                 :postalcode => /# Postcode format

  #                                 /d{5} #Prefix

  #                                 (-/d{4})? #Suffix

  #                                 /x

  #               }

  #

  # Using the multiline match modifier will raise an ArgumentError.

  # Encoding regular expression modifiers are silently ignored. The

  # match will always use the default encoding or ASCII.

  #

  7） Route globbing

  #

  # Specifying <tt>*[string]</tt> as part of a rule like:

  #

  #   map.connect '*path' , :controller => 'blog' , :action => 'unrecognized?'

  #

  # will glob all remaining parts of the route that were not recognized earlier. This idiom

  # must appear at the end of the path. The globbed values are in <tt>params[:path]</tt> in

  # this case.

  #

  8） Route conditions

  #

  # With conditions you can define restrictions on routes. Currently the only valid condition is <tt>:method</tt>.

  #

  # * <tt>:method</tt> - Allows you to specify which method can access the route. Possible values are <tt>:post</tt>,

  #   <tt>:get</tt>, <tt>:put</tt>, <tt>:delete</tt> and <tt>:any</tt>. The default value is <tt>:any</tt>, 

  #   <tt>:any</tt> means that any method can access the route.

  #

  # Example:

  #

  #   map.connect 'post/:id', :controller => 'posts', :action => 'show',

  #               :conditions => { :method => :get }

  #   map.connect 'post/:id', :controller => 'posts', :action => 'create_comment',

  #               :conditions => { :method => :post }

  #

  # Now, if you POST to <tt>/posts/:id</tt>, it will route to the <tt>create_comment</tt> action. A GET on the same

  # URL will route to the <tt>show</tt> action.

  # 

  9） Reloading routes

  #

  # You can reload routes if you feel you must:

  #

  #   ActionController::Routing::Routes.reload

  #

  # This will clear all named routes and reload routes.rb if the file has been modified from

  # last load. To absolutely force reloading, use <tt>reload!</tt>.

  #

  10） Testing Routes

  #

  # The two main methods for testing your routes:

  #

  # === +assert_routing+

  #

  #   def test_movie_route_properly_splits

  #    opts = {:controller => "plugin", :action => "checkout", :id => "2"}

  #    assert_routing "plugin/checkout/2", opts

  #   end

  #

  # +assert_routing+ lets you test whether or not the route properly resolves into options.

  #

  # === +assert_recognizes+

  #

  #   def test_route_has_options

  #    opts = {:controller => "plugin", :action => "show", :id => "12"}

  #    assert_recognizes opts, "/plugins/show/12"

  #   end

  #

  # Note the subtle difference between the two: +assert_routing+ tests that

  # a URL fits options while +assert_recognizes+ tests that a URL

  # breaks into parameters properly.

  #

  # In tests you can simply pass the URL or named route to +get+ or +post+.

  #

  #   def send_to_jail

  #     get '/jail'

  #     assert_response :success

  #     assert_template "jail/front"

  #   end

  #

  #   def goes_to_login

  #     get login_url

  #     #...

  #   end

  #

  # == View a list of all your routes

  #

  # Run <tt>rake routes</tt>.

  #

1. require 'cgi'
2. require 'uri'
3. require 'action_controller/polymorphic_routes'
4. require 'action_controller/routing/optimisations'
5. require 'action_controller/routing/routing_ext'
6. require 'action_controller/routing/route'
7. require 'action_controller/routing/segments'
8. require 'action_controller/routing/builder'
9. require 'action_controller/routing/route_set'
10. require 'action_controller/routing/recognition_optimisation'
12. module ActionController
13.   
14.   module Routing
15.     SEPARATORS = %w( / . ? )
17.     HTTP_METHODS = [:get, :head, :post, :put, :delete]
19.     ALLOWED_REQUIREMENTS_FOR_OPTIMISATION = [:controller, :action].to_set
21.     # The root paths which may contain controller files
22.     mattr_accessor :controller_paths
23.     self.controller_paths = []
25.     # A helper module to hold URL related helpers.
26.     module Helpers
27.       include PolymorphicRoutes
28.     end
30.     class << self
31.       # Expects an array of controller names as the first argument.  
32.       # Executes the passed block with only the named controllers named available.
33.       # This method is used in internal Rails testing.
34.       def with_controllers(names)
35.         prior_controllers = @possible_controllers
36.         use_controllers! names
37.         yield
38.       ensure
39.         use_controllers! prior_controllers
40.       end
42.       # Returns an array of paths, cleaned of double-slashes and relative path references.
43.       # * "///" and "//"  become "//" or "/". 
44.       # * "/foo/bar/../config" becomes "/foo/config".
45.       # The returned array is sorted by length, descending.
46.       def normalize_paths(paths) # 正则化路径
47.         # do the hokey-pokey of path normalization...
48.         paths = paths.collect do |path|
49.           path = path.
50.             gsub("//", "/").           # replace double / chars with a single
51.             gsub("////", "//").        # replace double / chars with a single
52.             gsub(%r{(.)[///]$}, '/1')  # drop final / or / if path ends with it
54.           # eliminate .. paths where possible
55.           re = %r{[^///]+[///]/./.[///]}
56.           path.gsub!(re, "") while path.match(re)
57.           path
58.         end
60.         # start with longest path, first
61.         paths = paths.uniq.sort_by { |path| - path.length }
62.       end
64.       # Returns the array of controller names currently available to ActionController::Routing.
65.       def possible_controllers
66.         unless @possible_controllers
67.           @possible_controllers = []
69.           paths = controller_paths.select { |path| File.directory?(path) && path != "." }
71.           seen_paths = Hash.new {|h, k| h[k] = true; false} 
72.           # 这个初始化Hash用法很特别,等于定义一个proc,
73.           # 每次调用后会如果为空根据这个proc创建一个默认的值
74.           normalize_paths(paths).each do |load_path|
75.             Dir["#{load_path}/**/*_controller.rb"].collect do |path|
76.               next if seen_paths[path.gsub(%r{^/.[///]}, "")] # 如果重复加载 那么忽略
78.               controller_name = path[(load_path.length + 1)..-1] # 获得controller名字
80.               controller_name.gsub!(/_controller/.rb/Z/, '')
81.               @possible_controllers << controller_name
82.             end
83.           end
85.           # remove duplicates
86.           @possible_controllers.uniq!
87.         end
88.         @possible_controllers
89.       end
91.       # Replaces the internal list of controllers available to ActionController::Routing with the passed argument.
92.       #   ActionController::Routing.use_controllers!([ "posts", "comments", "admin/comments" ])
93.       def use_controllers!(controller_names)
94.         @possible_controllers = controller_names
95.       end
97.       # Returns a controller path for a new +controller+ based on a +previous+ controller path.
98.       # Handles 4 scenarios:
99.       #
100.       # * stay in the previous controller:
101.       #     controller_relative_to( nil, "groups/discussion" ) # => "groups/discussion"
102.       #
103.       # * stay in the previous namespace:
104.       #     controller_relative_to( "posts", "groups/discussion" ) # => "groups/posts"
105.       #
106.       # * forced move to the root namespace:
107.       #     controller_relative_to( "/posts", "groups/discussion" ) # => "posts"
108.       #
109.       # * previous namespace is root:
110.       #     controller_relative_to( "posts", "anything_with_no_slashes" ) # =>"posts"
111.       #
112.       
113.       def controller_relative_to(controller, previous)
114.         if controller.nil?           then previous
115.         elsif controller[0] == ?/    then controller[1..-1]
116.         elsif %r{^(.*)/} =~ previous then "#{$1}/#{controller}"
117.         else controller
118.         end
119.       end
120.     end
121.     
123.     Routes = RouteSet.new
125.     ::Inflector.module_eval do
126.       # Ensures that routes are reloaded when Rails inflections are updated.
127.       def inflections_with_route_reloading(&block)
128.         returning(inflections_without_route_reloading(&block)) {
129.           ActionController::Routing::Routes.reload! if block_given?
130.         }
131.       end
133.       alias_method_chain :inflections, :route_reloading
134.     end
135.   end
136. end