Ruby on Rails Reading Guide

Slides for RailsConf 2014 talk "Ruby on Rails Reading Guide" http://www.railsconf.com/

1. Akira Matsuda Ruby on Rails Hacking Guide
2. before
3. pp self name: Akira Matsuda GitHub: amatsuda Twitter: @a_matsuda committer of: Ruby, Rails, Haml from: Tokyo, Japan founder of: Asakusa.rb an organizer of: RubyKaigi
4. amatsuda creator of: kaminari, active_decorator, action_args, html5_validators, hocus_pocus, erd, everywhere, i18n_generators, database_rewinder, rfd...
5. A Rails committer
6. Contributing to Rails 374 commits so far Since 6.years.ago
7. Akira Matsuda Ruby on Rails Hacking Guide
8. Akira Matsuda Ruby on Rails Reading Guide
9. Why should we read Rails? We're "Software Writers" (DHH) We'd better know what's happening underneath our apps You'll occasionally hit Rails bugs
10. We're "Software Writers" (DHH) You need to read good software if you want to be a good "software writer"
11. We'd better know what's happening underneath our apps Short code does a lot of works Magical DSLs
12. Short code does a lot of works class UsersController < ApplicationController def index @users = User.all end end
13. Magical DSLs Rails.application.routes.draw do get "/hello" => "foo#bar" end
14. You'll occasionally hit Rails bugs
15. Rails.has_many :bugs We often hit them in production apps We need to x them We need to be familiar with the codebase
16. This talk Novice?
17. begin
18. Chapters Let's start reading! How Rails server boots (1) What is Railties? How Rails server boots (2) Rails and Rack middleware Routes Controllers and actions
19. Let's start reading! Chapter 1
20. Ruby on Rails is_a Open-source On GitHub 100% Ruby No C extensions!
21. Source code % git clone rails/rails (Of course you're using hub right?)
22. Pro tip: Use gem-src How can you nd the GH repo for the gem you use? Don't want to manually git-clone every gem that you read or patch? Use gem-src
23. amatsuda/gem-src Installation (as an rbenv plugin) % git clone https://github.com/ amatsuda/gem-src.git ~/.rbenv/ plugins/gem-src Con guration % echo "gemsrc_clone_root: ~/ src" >> ~/.gemrc
24. gem-src (a social coder's best friend) Usage % gem i rails #=> automatically git-clone You no more need to memorize the gem author name, or search in GitHub!
25. Source code % cd rails
26. Ingredients of Rails Let's see what's included in the gem
27. What's included in the rails gem? Take a look at the gemspec
28. rails.gemspec s.files = ['README.md'] + Dir['guides/**/*']
29. rails.gemspec This gem doesn't really include any program
30. rails.gemspec s.add_dependency 'activesupport', version s.add_dependency 'actionpack', version s.add_dependency 'actionview', version s.add_dependency 'activemodel', version s.add_dependency 'activerecord', version s.add_dependency 'actionmailer', version s.add_dependency 'railties', version
31. rails.gemspec It has no code, but instead it de nes several dependencies It means that the rails gem is a meta package to install these 7 gems
32. Directories in the rails project % lsd # aliased to ls -ld *(-/DN) actionmailer actionpack actionview activemodel activerecord activesupport railties
33. 7 dependencies You can nd them at the top directory in the rails repo
34. What are these 7 gems? The whole MVC + something more
35. Rails is a full-stack MVC framework All the Rails MVC components are in this one repository
36. MVC View Controller Model
37. MVC components View ActionView Controller ActionPack Model ActiveModel ActiveRecord
38. M - activemodel, activerecord class Recipe < ActiveRecord::Base ... end
39. V - actionview app/views/**/*.html.haml
40. C - actionpack class ApplicationController < ActionController::Base end
41. Summary: Let's start reding! rails gem is a meta package that depends on other 7 gems including the whole MVC components
42. How Rails server boots (1) Chapter 2
43. The "rails" command % rails server Rails.root/bin/rails
44. Rails.root/bin/rails require_relative '../config/boot' require 'rails/commands'
45. Rails.root/bin/rails Requires 'con g/boot' inside the app Requires 'rails/commands'
46. Rails.root/con g/boot.rb require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
47. Rails.root/con g/boot.rb Sets up gems listed in the Gem le Tweaks the $LOAD_PATH (Bundler)
48. require 'rails/commands' Where's "rails" directory? You can nd it in railties gem
49. Wait, what is raities gem?
50. What is railties? Chapter 3
51. railties.gemspec s.summary = 'Tools for creating, working with, and running Rails applications.' s.description = 'Rails internals: application bootup, plugins, generators, and rake tasks.'
52. railties.gemspec s.files = Dir['CHANGELOG.md', 'README.rdoc', 'RDOC_MAIN.rdoc', 'bin/**/*', 'lib/**/{*,.[a-z]*}'] s.executables = ['rails']
53. railties/lib % cd railties/lib % ls rails rails.rb
54. rails/commands.rb (in railties gem) require 'rails/commands/commands_tasks' Rails::CommandsTasks.new(ARGV).run_command!(command)
55. rails/commands.rb Requires 'rails/commands/ commands_tasks' Invokes a command task with the given name
56. rails/commands/ commands_tasks.rb module Rails class CommandsTasks def server ... require "rails/commands/server" Rails::Server.new.tap do |server| require APP_PATH ... server.start ennnd
57. CommandsTasks#server Requires "rails/commands/ server"
58. rails/commands/server.rb ... require 'rails' module Rails class Server < ::Rack::Server def initialize(*) super ENV["RAILS_ENV"] ||= options[:environment] end def start super ennnd
59. rails/commands/server.rb Requires 'rails'
60. require 'rails' Requires rails.rb le at the top of lib directory
61. rails.rb require 'rails/application' module Rails ... end
62. rails.rb Requires 'rails/application' De nes a top-level module named Rails
63. rails/application.rb require 'rails/engine' module Rails class Application < Engine ... ennd
64. rails/application.rb Requires 'rails/engine' De nes Rails::Application class inheriting Rails::Engine
65. rails/engine.rb require 'rails/railtie' module Rails class Engine < Railtie ... ennd
66. rails/engine.rb Requires 'rails/railtie' De nes Rails::Engine class inheriting Rails::Railtie
67. rails/railtie.rb require 'rails/initializable' require 'rails/configuration' module Rails class Railtie include Initializable ... ennd
68. rails/railtie.rb Requires 'rails/initializable' Requires 'rails/con guration' De nes Rails::Railtie class that includes Rails::Initializable
69. rails/initializable.rb module Rails module Initializable class Initializer ... ennnd
70. rails/initializable.rb De nes Rails::Initializable De nes Rails::Initializable::Initializer
71. What we learned Railties de nes these core classes MyApp::Application < Application < Engine < Railtie < Initializable
72. Railties is the core of Rails View ActionView Controller ActionPack Model ActiveModel ActiveRecord Railties
73. Plugin? Engine < Plugin (until 3.2) Gone since Rails 4
74. Pro tip: Tools to read it through Vim + unite.vim (unite-outline) rdefs RubyMine
75. What is railties? It's a library providing something underneath the Rails Application Another answer is...
76. Railroad tie According to WIKIPEDIA... http://en.wikipedia.org/wiki/ Railroad_tie
77. Railroad tie "a rectangular support for the rails in railroad tracks" "Generally laid perpendicular to the rails" "Railroad ties were traditionally made of wood"
78. Railroad tie "railroad tie/railway tie/crosstie (North America), or railway sleeper (Europe, Australia & Asia)"
79. Railroad tie "QQMJDBUJPOT 3BJMT 3BJMUJFT http://ja.wikipedia.org/wiki/৽װઢ
80. How is Railties actually used?
81. Railties in Rails % git grep Rails::Railtie actionmailer/lib/action_mailer/railtie.rb: class Railtie < Rails::Railtie # :nodoc: actionpack/lib/action_controller/railtie.rb: class Railtie < Rails::Railtie #:nodoc: actionpack/lib/action_dispatch/railtie.rb: class Railtie < Rails::Railtie # :nodoc: actionview/lib/action_view/railtie.rb: class Railtie < Rails::Railtie # :nodoc: activemodel/lib/active_model/railtie.rb: class Railtie < Rails::Railtie # :nodoc: activerecord/lib/active_record/railtie.rb: class Railtie < Rails::Railtie # :nodoc: activesupport/lib/active_support/i18n_railtie.rb: class Railtie < Rails::Railtie activesupport/lib/active_support/railtie.rb: class Railtie < Rails::Railtie # :nodoc:
82. Railties in Rails % vim **/*railtie.rb
83. Each component has its own Railtie inheriting Rails::Railtie module ActionMailer class Railtie < Rails::Railtie module ActionController class Railtie < Rails::Railtie module ActionDispatch class Railtie < Rails::Railtie module ActionView class Railtie < Rails::Railtie module ActiveModel class Railtie < Rails::Railtie module ActiveRecord class Railtie < Rails::Railtie
84. We see Railtie everywhere! View ActionView Controller ActionPack Model ActiveModel ActiveRecord Railties Railtie Railtie Railtie
85. What's written in a Railtie? (active_model/railtie.rb) require "active_model" require "rails" module ActiveModel class Railtie < Rails::Railtie # :nodoc: config.eager_load_namespaces << ActiveModel initializer "active_model.secure_password" do ActiveModel::SecurePassword.min_cost = Rails.env.test? end ennd
86. What's written in a Railtie? Mainly we see two kinds of class method calls, con g and initializer
87. What is con g?
88. What is con g? (railtie/railtie.rb) module Rails class Railtie def config @config ||= Railtie::Configuration.new ennnd
89. What is con g? It's an instance of Railtie::Con guration
90. Railtie::Con guration? (railtie/con guration.rb) module Rails class Railtie class Configuration def method_missing(name, *args, &blk) if name.to_s =~ /=$/ @@options[$`.to_sym] = args.first elsif @@options.key?(name) @@options[name] else super end ennnnd
91. Railtie::Con guration? It accepts any method call and stores the given method name & value in a class level Hash as {method_name: value}
92. What is initializer?
93. What is initializer? (rails/initializable.rb) module Rails module Initializable class Initializer attr_reader :name, :block def initialize(name, context, options, &block) ... @name, @context, @options, @block = name, context, options, block ennd module ClassMethods def initializer(name, opts = {}, &blk) ... initializers << Initializer.new(name, nil, opts, &blk) ennnnd
94. What is initializer? It just keeps the given block as a Proc instance (with a name and options)
95. What Railtie is doing Setting some values via con g.foobar = 'baz' Storing Procs given to initializer method calls
96. One more thing about Rails::Railtie (rails/railtie.rb) module Rails class Railtie ... class << self private :new
97. One more thing about Rails::Railtie Prohibited to be instantiated from outside self.instance returns the singleton instance Why is it a class despite you can't instantiate?
98. Why is it a class despite you can't instantiate? In order to be able to be inherited
99. What's gonna happen when Rails::Railtie is inherited? (rails/railtle.rb) module Rails class Railtie class << self def inherited(base) unless base.abstract_railtie? subclasses << base ennnnnd
100. What's gonna happen when Rails::Railtie is inherited? Rails::Railtie memorizes the children classes
101. We see Railtie everywhere! View ActionView Controller ActionPack Model ActiveModel ActiveRecord Railties Railtie Railtie Railtie
102. Summary: What is railties? Railties is the core of Rails that provides Railtie, Engine, Application, etc. We can nd "Railtie"s in other Rails components A "Railtie" can keep "con g" and "initializer" values Railties ties up these "Railtie"s
103. How Rails server boots (2) Chapter 4
104. rails/commands/ commands_tasks.rb module Rails class CommandsTasks def server ... require "rails/commands/server" Rails::Server.new.tap do |server| require APP_PATH ... server.start ennnd
105. CommandsTasks#server Requires "rails/commands/ server"
106. rails/commands/server.rb ... require 'rails' module Rails class Server < ::Rack::Server def initialize(*) super ENV["RAILS_ENV"] ||= options[:environment] end def start super ennnd
107. rails/commands/server.rb Calls ::Rack::Server#start via super()
108. rack-1.5.2/lib/rack/server.rb module Rack class Server def start &blk ... ennnd
109. I'm not gonna do rack code reading here But method calls go on like start => wrapped_app => app => build_app_and_options_from_co n g => Rack::Builder.parse_ le => Rack::Builder.new_from_string
110. Anyway, Rack nally executes something like this
111. rack/builder.rb eval "Rack::Builder.new {\n" + ::File.read('config.ru') + "\n}.to_app", TOPLEVEL_BINDING, '(rackup)', 0
112. Rack::Builder.new module Rack class Builder def initialize(default_app = nil,&block) ... instance_eval(&block) if block_given? sennnd
113. Rails.root/con g.ru require ::File.expand_path('../config/environment', __FILE__) run Rails.application
114. Rails.root/con g.ru Requires Rails.root/con g/ environment.rb Runs Rails.application
115. Pro tip: `puts caller` Find it difficult to follow the method calls? Add `puts caller` to con g.ru le and start the server.
116. Rails.root/con g.ru # This file is used by Rack-based servers to start the application. puts caller require ::File.expand_path('../config/environment', __FILE__) run Rails.application
117. `puts caller` Then you'll get an output like this...
118. `puts caller` from con g.ru #{GEM_HOME}/rack-1.5.2/lib/rack/builder.rb:55:in `instance_eval' #{GEM_HOME}/rack-1.5.2/lib/rack/builder.rb:55:in `initialize' #{Rails.root}/config.ru:in `new' #{Rails.root}/config.ru:in `<main>' #{GEM_HOME}/rack-1.5.2/lib/rack/builder.rb:49:in `eval' #{GEM_HOME}/rack-1.5.2/lib/rack/builder.rb:49:in `new_from_string' #{GEM_HOME}/rack-1.5.2/lib/rack/builder.rb:40:in `parse_file' #{GEM_HOME}/rack-1.5.2/lib/rack/server.rb:126:in `build_app_and_options_from_config' #{GEM_HOME}/rack-1.5.2/lib/rack/server.rb:82:in `app' #{GEM_HOME}/railties-4.1.0.rc1/lib/rails/commands/server.rb:50:in `app' #{GEM_HOME}/rack-1.5.2/lib/rack/server.rb:163:in `wrapped_app' #{GEM_HOME}/railties-4.1.0.rc1/lib/rails/commands/server.rb:130:in `log_to_stdout' #{GEM_HOME}/railties-4.1.0.rc1/lib/rails/commands/server.rb:67:in `start' #{GEM_HOME}/railties-4.1.0.rc1/lib/rails/commands/commands_tasks.rb:82:in `block in server' #{GEM_HOME}/railties-4.1.0.rc1/lib/rails/commands/commands_tasks.rb:77:in `tap' #{GEM_HOME}/railties-4.1.0.rc1/lib/rails/commands/commands_tasks.rb:77:in `server' #{GEM_HOME}/railties-4.1.0.rc1/lib/rails/commands/commands_tasks.rb:41:in `run_command!' #{GEM_HOME}/railties-4.1.0.rc1/lib/rails/commands.rb:17:in `<top (required)>' ./bin/rails:8:in `require' ./bin/rails:8:in `<main>'
119. Pro tip: `puts caller` Remember to use caller when you get lost in the method call hell.
120. Rails.root/con g/ environment.rb require File.expand_path('../application', __FILE__) Rails.application.initialize!
121. Rails.root/con g/ environment.rb Requires Rails.root/con g/ application.rb Calls Rails.application.initialize!
122. Rails.root/con g/ application.rb require 'rails/all' Bundler.require(*Rails.groups) module YourApp class Application < Rails::Application end end
123. Rails.root/con g/ application.rb Requires 'rails/all' Requires bundled gems De nes Rails.application
124. rails/all.rb require "rails" %w( active_record action_controller action_view action_mailer rails/test_unit sprockets ).each do |framework| begin require "#{framework}/railtie" rescue LoadError end end
125. rails/all.rb (edited) require 'active_record/railtie' require 'action_controller/railtie' require 'action_view/railtie' require 'action_mailer/railtie' require 'rails/test_unit/railtie' require 'sprockets/railtie'
126. */railtie.rb De nes con gs and initializers, as we have seen already
127. And then, what happens next is... Rails.application.initialize!
128. Rails.application.initialize! (rails/application.rb) module Rails class Application < Engine def initialize!(group=:default) ... run_initializers(group, self) ... ennnd
129. Rails.application.initialize! Calls run_initializers
130. run_initializers (rails/initializable.rb) module Rails module Initializable def run_initializers(group=:default, *args) ... initializers.tsort_each do |initializer| initializer.run(*args) if initializer.belongs_to?(group) end ... ennd
131. How the initializers are run? Calls #run method for each Initializer object in the initializers collection
132. Initializer#run (rails/initializable.rb) module Rails module Initializable class Initializer def run(*args) @context.instance_exec(*args, &block) ennnnd
133. Initializer#run It simply instance_execs the stored Proc in some context stored in @context @context is actually the application instance
134. All the Initializers (rails/application.rb) module Rails class Application < Engine ... def initializers Bootstrap.initializers_for(self) + railties_initializers(super) + Finisher.initializers_for(self) ennnd
135. What's in the initializers collection? (rails/initializable.rb) module Rails module Initializable module ClassMethods def initializer(name, opts = {}, &blk) ... initializers << Initializer.new(name, nil, opts, &blk) ennnnd
136. What's in the initializers collection? Instances of Rails::Initializable::Initializer Each Initializer just holds a Proc instance (and a name and options) given to Rails::Railtie::Initializable.initializ e method call
137. Who calls Rails::Railtie.initialize? Railtie subclasses such as ActiveRecord::Railtie, ActionPack::Railtle, etc.
138. rails/commands.rb Requires 'rails/commands/ commands_tasks'
139. rails/commands/server.rb ... require 'rails' module Rails class Server < ::Rack::Server def initialize(*) super ENV["RAILS_ENV"] ||= options[:environment] end def start super ennnd
140. rails/commands/server.rb Requires 'rails'
141. Summary: How Rails server boots Require all gems in the Gem le (bundler) Load all Railties and Engines (con g/application.rb) De ne YourApp::Application inheriting Rails::Application (con g/application.rb) Run Railtie#initializer de ned in each Railtie, Engine, and Application Load each Engine's load_path and routes, then load con g/initializers/* Run Rails.application (con g.ru) => The next chapter
142. Building middleware stack Chapter 5
143. con g.ru run Rails.application
144. run Rails.application With this de nition, the Rack server calls `Rails.application.call(env)`
145. Rails.application responds_to :call Rails.application is_a Rack app
146. Rails.application as a Rack application (railties/lib/rails/applicaiton.rb) module Rails class Application ... def call(env) ... super(env) ennnd
147. Rails::Application#call Calls super The super class is Rails::Engine
148. Rails::Engine is also a Rack app (railties/lib/rails/engine.rb) module Rails class Engine ... def call(env) ... app.call(env) ennnd
149. Rails::Engine is also a Rack app The call goes to app.call
150. What's app? (railties/lib/rails/engine.rb) module Rails class Engine ... def app @app ||= begin config.middleware = config.middleware.merge_into(default_middleware_stack) config.middleware.build(endpoint) end ennnd
151. What's app? app is con g.middleware that contains default_middleware_stack and endpoint
152. What is con g.middleware? (rails/engine/con guration.rb) module Rails class Engine class Configuration < ::Rails::Railtie::Configuration def middleware @middleware ||= Rails::Configuration::MiddlewareStackProxy.new ennnnd
153. What is Rails::Con guration::MiddlewareStackProxy? (rails/con guration.rb) module Rails module Configuration class MiddlewareStackProxy def initialize @operations = [] ennnnd
154. What is Rails::Con guration::MiddlewareStackProxy? Basically it's a stack that proxies the Rails middleware stack
155. app = default_middlewarestack + endpoint (railties/lib/rails/engine.rb) module Rails class Engine ... def app @app ||= begin config.middleware = config.middleware.merge_into(default_middleware_stack) config.middleware.build(endpoint) end ennnd
156. What's the endpoint? (rails/engine.rb) module Rails class Engine < Railtie def endpoint self.class.endpoint || routes end def routes @routes ||= ActionDispatch::Routing::RouteSet.new ... ennnd
157. What's the endpoint? endpoint = routes (is_a ActionDispatch::Routing::RouteS et) by default
158. Summary: Building middleware stack The Rack server calls `Rails.application.call` It calls the Rails default middleware stack and the endpoint The endpoint is "routes"
159. Routes Chapter 6
160. Rails.application.routes Usually written in Rails.root/ con g/routes.rb
161. An example routes.rb (Rails.root/con g/routes.rb) Rails.application.routes.draw do get "/hello" => "foo#bar" end
162. What is routes? Rails.application.routes.class => ActionDispatch::Routing::RouteSet
163. Rails.application.routes is also a Rack app (action_dispatch/routing/route_set.rb) module ActionDispatch module Routing class RouteSet ... def call(env) @router.call(env) ennnnd
164. What is @router? (action_dispatch/routing/route_set.rb) module ActionDispatch module Routing class RouteSet ... def initialize(request_class = ActionDispatch::Request) ... @set = Journey::Routes.new @router = Journey::Router.new(@set, { :parameters_key => PARAMETERS_KEY, :request_class => request_class}) @formatter = Journey::Formatter.new @set ennnnd
165. What is @router? It's a Journey thing!
166. Rails.application.routes is also a Rack app This is how Rails.application's endpoint accepts the Rack request But for now, let's go back to routes.draw DSL
167. De ning routes
168. routes.draw (action_dispatch/routing/route_set.rb) module ActionDispatch module Routing class RouteSet def draw(&block) ... eval_block(block) ... end def eval_block(block) ... mapper = Mapper.new(self) mapper.instance_exec(&block) ennnnd
169. routes.draw instance_execs the whole given block with an instance of ActionDispatch::Routing::Mapper
170. This DSL calls AD::Routing::Mapper#get (Rails.root/con g/routes.rb) Rails.application.routes.draw do get "/hello" => "foo#bar" end
171. AD::Routing::Mapper#get (action_dispatch/routing/mapper.rb) module ActionDispatch module Routing class Mapper def get(*args, &block) map_method(:get, args, &block) end def map_method(method, args, &block) ... match(*args, options, &block) ... end def match(path, *rest) ... decomposed_match(_path, route_options) end def decomposed_match(path, options) add_route(path, options) ennnnnd
172. AD::Routing::Mapper#get Mapper#get nally goes to Mapper#add_route
173. Mapper#add_route (action_dispatch/routing/mapper.rb) module ActionDispatch module Routing class Mapper ... def add_route(action, options) ... mapping = Mapping.new(@set, @scope, URI.parser.escape(path), options) app, conditions, requirements, defaults, as, anchor = mapping.to_route @set.add_route(app, conditions, requirements, defaults, as, anchor) ennnnnd
174. add_routes returns a Journey::Route (action_dispatch/journey/routes.rb) module ActionDispatch module Journey class Routes def add_route(app, path, conditions, defaults, name = nil) route = Route.new(name, app, path, conditions, defaults) route.precedence = routes.length routes << route ennnnd
175. Mapper#add_route Finally adds a new Journey::Route to routes Makes a Mapper#to_route call
176. Mapper#to_route => app (action_dispatch/routing/mapper.rb) module ActionDispatch module Routing class Mapper ... def to_route [ app, conditions, requirements, defaults, options[:as], options[:anchor] ] end def app Constraints.new(endpoint, blocks, @set.request_class) ennnnnnd
177. Constraints.new (action_dispatch/routing/mapper.rb) module ActionDispatch module Routing class Mapper class Constraints def self.new(app, constraints, request = Rack::Request) if constraints.any? super(app, constraints, request) else app end ennnnnd
178. What is endpoint? (action_dispatch/routing/mapper.rb) module ActionDispatch module Routing class Mapper class Mapping ... def endpoint to.respond_to?(:call) ? to : dispatcher ennnnnnd
179. to.respond_to?(:call) ?? Possibly An endpoint can be a Rack app or a mounted Engine
180. to.respond_to?(:call) ?? get "/ok" => ->(env) { [200, {}, ["OK"]] }
181. "foo#bar" does not respond_to :call (action_dispatch/routing/mapper.rb) module ActionDispatch module Routing class Mapper class Mapping ... def dispatcher Routing::RouteSet::Dispatcher.new( :defaults => defaults) ennnnnnd
182. Dispatcher is a Rack app (action_dispatch/routing/route_set.rb) module ActionDispatch module Routing class RouteSet class Dispatcher def call(env) ... dispatch(controller, params[:action], env) end def dispatch(controller, action, env) controller.action(action).call(env) ennnnnd
183. controller.action(action) is a Rack app > FooController.action('bar') => #<Proc:0x007fa63e990408@.../ action_controller/metal.rb:230>
184. get "/hello" => "foo#bar" Maps "/hello" to a Proc returned by FooController.action('bar')
185. Resolving routes
186. Calls to the router Rails.application.routes.call(env)
187. Rails.application.router module ActionDispatch module Routing class RouteSet def initialize(request_class = ActionDispatch::Request) ... @set = Journey::Routes.new @router = Journey::Router.new(@set, { :parameters_key => PARAMETERS_KEY, :request_class => request_class}) @formatter = Journey::Formatter.new @set ennnnd
188. RouteSet#call => Journey::Router#call module ActionDispatch module Routing class RouteSet ... def call(env) @router.call(env) ennnnd
189. Journey::Router#call It's another long journey... Anyway it resolves the route
190. Summary: Routes Rails.application.routes is a Rack app Each routes' endpoint is a Rack app Each controller's each action is a Rack app e.g. 'foo#bar' becomes a Rack app generated by FooController.action('bar') Everything is a Rack app
191. Controllers and actions Chapter 7
192. What's gonna happen when the server got a Request? controller.action(action).call(env)
193. controller.action(action).call(env) (action_dispatch/routing/route_set.rb) module ActionDispatch module Routing class RouteSet class Dispatcher def call(env) ... dispatch(controller, params[:action], env) end def dispatch(controller, action, env) controller.action(action).call(env) ennnnnd
194. Creating a Request object, and adding a Proc to the stack (action_controller/metal.rb) module ActionController class Metal < AbstractController::Base def self.action(name, klass = ActionDispatch::Request) middleware_stack.build(name.to_s) do |env| new.dispatch(name, klass.new(env)) end ennnd
195. Creating a Response object (action_controller/metal/rack_delegation.rb) module ActionController module RackDelegation def dispatch(action, request) set_response!(request) super(action, request) end def set_response!(request) @_response = ActionDispatch::Response.new @_response.request = request ennnd
196. AC::Metal#dispatch (action_controller/metal.rb) module ActionController class Metal < AbstractController::Base def dispatch(name, request) @_request = request @_env = request.env @_env['action_controller.instance'] = self process(name) to_a ennnd
197. AC::Metal#dispatch Calls AC::Metal#process
198. Controller#process (abstract_controller/base.rb) module AbstractController class Base def process(action, *args) ... process_action(action_name, *args) end private def process_action(method_name, *args) send_action(method_name, *args) end alias send_action send ennnd
199. Controller#process_action process_action(action_name, *args) is equivalent to send action_name
200. Summary: Controllers and actions The request goes to FooController.action('bar') FooController.action('bar') sets the Rails Request and Response objects to the controller instance Then call goes to FooController#bar via `send` call
201. ... and more
202. end