Ruby on Rails Hacking Guide

Slide 1

Slide 1 text

Ruby on Rails Hacking Guide Akira Matsuda

Slide 2

Slide 2 text

before

Slide 3

Slide 3 text

self.name Akira Matsuda != matz

Slide 4

Slide 4 text

pp self GitHub: amatsuda Twitter: @a_matsuda committer of: Ruby, Rails, Haml from: Tokyo, Japan founder of: Asakusa.rb an organizer of: RubyKaigi

Slide 5

Slide 5 text

amatsuda creator of: kaminari, active_decorator, action_args, html5_validators, hocus_pocus, erd, everywhere, i18n_generators, database_rewinder, rfd...

Slide 6

Slide 6 text

A Rails committer

Slide 7

Slide 7 text

Contributing to Rails 372 commits so far Since 6.years.ago

Slide 8

Slide 8 text

My motivation

Slide 9

Slide 9 text

Rails.has_many :bugs I often hit them in my production apps I need to x them I need to understand the code

Slide 10

Slide 10 text

How could I understand the code? I read it, and read it, and I read it I spent too much time reading and learning the code I don't want all other contributors to repeat that waste of time

Slide 11

Slide 11 text

I spent too much time reading and learning the code Because I learned it without a guide I wish I had a good guide like "Ruby Hacking Guide" by Minero Aoki So I'm speaking and writing

Slide 12

Slide 12 text

How could I hit Rails bug so often? Use Edge Rails In your hobby apps Don't trust Rails Rails should work as you expect Remove silencers!

Slide 13

Slide 13 text

Remove silencers! (Rails.root/con g/initializers/ backtrace_silencers.rb) # Rails.backtrace_cleaner.remove_silencers! => Rails.backtrace_cleaner.remove_silencers!

Slide 14

Slide 14 text

This talk How Rails works In MY understanding How I read the code

Slide 15

Slide 15 text

begin

Slide 16

Slide 16 text

Chapters Let's start reding! What is Railties? How Rails server boots Rails and Rack middleware Routes Controllers and actions ... and more

Slide 17

Slide 17 text

Let's start reading! Chapter 1

Slide 18

Slide 18 text

Ruby on Rails is_a Open-source On GitHub 100% Ruby No C extensions!

Slide 19

Slide 19 text

Source code % git clone rails/rails (Of course you're using hub right?)

Slide 20

Slide 20 text

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

Slide 21

Slide 21 text

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

Slide 22

Slide 22 text

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!

Slide 23

Slide 23 text

Source code % cd rails

Slide 24

Slide 24 text

Ingredients of Rails Let's see what's included in the gem

Slide 25

Slide 25 text

What's included in the rails gem? When you want to know what's included in the gem, take a look at the gemspec

Slide 26

Slide 26 text

rails.gemspec s.files = ['README.md'] + Dir['guides/**/*']

Slide 27

Slide 27 text

rails.gemspec This gem doesn't really include any program

Slide 28

Slide 28 text

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

Slide 29

Slide 29 text

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

Slide 30

Slide 30 text

Directories in the rails project % lsd # aliased to ls -ld *(-/DN) actionmailer actionpack actionview activemodel activerecord activesupport railties

Slide 31

Slide 31 text

7 dependencies You can nd them at the top directory in the rails repo

Slide 32

Slide 32 text

What are these 7 gems? The whole MVC + something more

Slide 33

Slide 33 text

Rails is a full-stack MVC framework All the Rails MVC components are in this one repository

Slide 34

Slide 34 text

MVC View Controller Model

Slide 35

Slide 35 text

MVC components View ActionView Controller ActionPack Model ActiveModel ActiveRecord

Slide 36

Slide 36 text

M - activemodel, activerecord class Recipe < ActiveRecord::Base ... end

Slide 37

Slide 37 text

V - actionview app/views/**/*.html.haml

Slide 38

Slide 38 text

C - actionpack class ApplicationController < ActionController::Base end

Slide 39

Slide 39 text

Back to the dependencies list You'll notice one gem that is not included in any of the MVC

Slide 40

Slide 40 text

Slide 41

Slide 41 text

Back to the dependencies list You'll notice one gem that is not included in any of the MVC Which is called railties

Slide 42

Slide 42 text

Summary: Let's start reding! rails gem is a meta package that depends on the whole MVC components There's a gem that is not included in any of the MVC components, which is called railties

Slide 43

Slide 43 text

What is railties? Chapter 2

Slide 44

Slide 44 text

Let's start reading railties Let's quickly walk through the code

Slide 45

Slide 45 text

railties.gemspec s.summary = 'Tools for creating, working with, and running Rails applications.' s.description = 'Rails internals: application bootup, plugins, generators, and rake tasks.'

Slide 46

Slide 46 text

railties.gemspec s.files = Dir['CHANGELOG.md', 'README.rdoc', 'RDOC_MAIN.rdoc', 'bin/**/*', 'lib/**/{*,.[a-z]*}'] s.executables = ['rails']

Slide 47

Slide 47 text

railties/lib % cd railties/lib

Slide 48

Slide 48 text

ls % ls rails rails.rb

Slide 49

Slide 49 text

rails.rb The le that will be required when you `require 'rails'` Let's start reading it!

Slide 50

Slide 50 text

rails.rb require 'rails/application' module Rails ... end

Slide 51

Slide 51 text

rails.rb Requires 'rails/application' De nes a top-level module named Rails

Slide 52

Slide 52 text

Requires 'rails/application' Apparently the next thing to read is rails/application.rb

Slide 53

Slide 53 text

rails/application.rb require 'rails/engine' module Rails class Application < Engine ... ennd

Slide 54

Slide 54 text

rails/application.rb Requires 'rails/engine' De nes Rails::Application class inheriting Rails::Engine

Slide 55

Slide 55 text

rails/engine.rb require 'rails/railtie' module Rails class Engine < Railtie ... ennd

Slide 56

Slide 56 text

rails/engine.rb Requires 'rails/railtie' De nes Rails::Engine class inheriting Rails::Railtie

Slide 57

Slide 57 text

rails/railtie.rb require 'rails/initializable' require 'rails/configuration' module Rails class Railtie include Initializable ... ennd

Slide 58

Slide 58 text

rails/railtie.rb Requires 'rails/initializable' Requires 'rails/con guration' De nes Rails::Railtie class that includes Rails::Initializable

Slide 59

Slide 59 text

rails/initializable.rb module Rails module Initializable class Initializer ... ennnd

Slide 60

Slide 60 text

rails/initializable.rb De nes Rails::Initializable De nes Rails::Initializable::Initializer

Slide 61

Slide 61 text

Files we have read rails.rb rails/application.rb rails/engine.rb rails/railtie.rb rails/initializable.rb

Slide 62

Slide 62 text

What we learned Railties de nes these core classes MyApp::Application < Application < Engine < Railtie < Initializable

Slide 63

Slide 63 text

Railties is the core of Rails View ActionView Controller ActionPack Model ActiveModel ActiveRecord Railties

Slide 64

Slide 64 text

Plugin? Engine < Plugin (until 3.2) Gone since Rails 4

Slide 65

Slide 65 text

Pro tip: Tools to read it through Vim + unite.vim (unite-outline) rdefs RubyMine

Slide 66

Slide 66 text

What is railties? It's a library providing something underneath the Rails Application Another answer is...

Slide 67

Slide 67 text

Railroad tie According to WIKIPEDIA... http://en.wikipedia.org/wiki/ Railroad_tie

Slide 68

Slide 68 text

Railroad tie "a rectangular support for the rails in railroad tracks" "Generally laid perpendicular to the rails" "Railroad ties were traditionally made of wood"

Slide 69

Slide 69 text

Railroad tie "railroad tie/railway tie/crosstie (North America), or railway sleeper (Europe, Australia & Asia)"

Slide 70

Slide 70 text

Railroad tie Applications Rails Railties http://ja.wikipedia.org/wiki/৽װઢ

Slide 71

Slide 71 text

How is Railties actually used?

Slide 72

Slide 72 text

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:

Slide 73

Slide 73 text

Railties in Rails % vim **/*railtie.rb

Slide 74

Slide 74 text

Each gems has their 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

Slide 75

Slide 75 text

We see Railtie everywhere! View ActionView Controller ActionPack Model ActiveModel ActiveRecord Railties Railtie Railtie Railtie

Slide 76

Slide 76 text

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

Slide 77

Slide 77 text

What's written in a Railtie? Mainly we see two kinds of class method calls, con g and initializer

Slide 78

Slide 78 text

What is con g?

Slide 79

Slide 79 text

What is con g? (railtie/railtie.rb) module Rails class Railtie def config @config ||= Railtie::Configuration.new ennnd

Slide 80

Slide 80 text

What is con g? It's an instance of Railtie::Con guration

Slide 81

Slide 81 text

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

Slide 82

Slide 82 text

Railtie::Con guration? It accepts any method call and stores the given method name & value in a class level Hash as {method_name: value}

Slide 83

Slide 83 text

What is initializer?

Slide 84

Slide 84 text

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

Slide 85

Slide 85 text

What is initializer? It just holds the given block as a Proc instance (with a name and options)

Slide 86

Slide 86 text

What Railtie is doing Sets some values via con g.foobar = 'baz' Stores Procs given to initializer method calls

Slide 87

Slide 87 text

One more thing about Rails::Railtie (rails/railtie.rb) module Rails class Railtie ... class << self private :new

Slide 88

Slide 88 text

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?

Slide 89

Slide 89 text

Why is it a class despite you can't instantiate? In order to be able to be inherited

Slide 90

Slide 90 text

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

Slide 91

Slide 91 text

What's gonna happen when Rails::Railtie is inherited? Rails::Railtie memorizes the children classes

Slide 92

Slide 92 text

We see Railtie everywhere! View ActionView Controller ActionPack Model ActiveModel ActiveRecord Railties Railtie Railtie Railtie

Slide 93

Slide 93 text

Summary: What is railties? Rails is Railties, all is Railties, so Railties is all

Slide 94

Slide 94 text

How Rails server boots Chapter 3

Slide 95

Slide 95 text

The "rails" command % rails server Rails.root/bin/rails

Slide 96

Slide 96 text

Rails.root/bin/rails require_relative '../config/boot' require 'rails/commands'

Slide 97

Slide 97 text

Rails.root/bin/rails Requires 'con g/boot' inside the app Requires 'rails/commands'

Slide 98

Slide 98 text

Rails.root/con g/boot.rb require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])

Slide 99

Slide 99 text

Rails.root/con g/boot.rb Sets up gems listed in the Gem le Tweaks the $LOAD_PATH (Bundler)

Slide 100

Slide 100 text

rails/commands.rb require 'rails/commands/commands_tasks' Rails::CommandsTasks.new(ARGV).run_command!(command)

Slide 101

Slide 101 text

rails/commands.rb Requires 'rails/commands/ commands_tasks' Invokes a command task with the given name

Slide 102

Slide 102 text

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

Slide 103

Slide 103 text

CommandsTasks#server Requires "rails/commands/ server" Requires the application Starts the server

Slide 104

Slide 104 text

rails/commands/server.rb module Rails class Server < ::Rack::Server def initialize(*) super ENV["RAILS_ENV"] ||= options[:environment] end def start super ennnd

Slide 105

Slide 105 text

Rails::Server#start Calls ::Rack::Server#start

Slide 106

Slide 106 text

rack-1.5.2/lib/rack/server.rb module Rack class Server def start &blk ... ennnd

Slide 107

Slide 107 text

I'm not gonna do rack code reading here But method calls go on like start => wrapped_app => app => build_app_and_options_from_ con g => Rack::Builder.parse_ le => Rack::Builder.new_from_string

Slide 108

Slide 108 text

Anyway, Rack nally executes something like this

Slide 109

Slide 109 text

rack/builder.rb eval "Rack::Builder.new {\n" + ::File.read('config.ru') + "\n}.to_app", TOPLEVEL_BINDING, '(rackup)', 0

Slide 110

Slide 110 text

Rack::Builder.new module Rack class Builder def initialize(default_app = nil,&block) ... instance_eval(&block) if block_given? sennnd

Slide 111

Slide 111 text

Rails.root/con g.ru require ::File.expand_path('../config/environment', __FILE__) run Rails.application

Slide 112

Slide 112 text

Rails.root/con g.ru Requires Rails.root/con g/ environment.rb Runs Rails.application

Slide 113

Slide 113 text

Pro tip: `puts caller` Find it diﬃcult to follow the method calls? Add `puts caller` to con g.ru le and start the server.

Slide 114

Slide 114 text

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

Slide 115

Slide 115 text

`puts caller` Then you'll get an output like this...

Slide 116

Slide 116 text

`puts caller` from con g.ru #{GEM_HOME}/rack-1.5.2/lib/rack/builder.rb:55:in ìnstance_eval' #{GEM_HOME}/rack-1.5.2/lib/rack/builder.rb:55:in ìnitialize' #{Rails.root}/config.ru:in `new' #{Rails.root}/config.ru:in `' #{GEM_HOME}/rack-1.5.2/lib/rack/builder.rb:49:in èval' #{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 àpp' #{GEM_HOME}/railties-4.1.0.rc1/lib/rails/commands/server.rb:50:in àpp' #{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 `' ./bin/rails:8:in `require' ./bin/rails:8:in `'

Slide 117

Slide 117 text

Pro tip: `puts caller` Remember to use caller when you get lost in the method call hell.

Slide 118

Slide 118 text

Rails.root/con g/ environment.rb require File.expand_path('../application', __FILE__) Rails.application.initialize!

Slide 119

Slide 119 text

Rails.root/con g/ environment.rb Requires Rails.root/con g/ application.rb Calls Rails.application.initialize!

Slide 120

Slide 120 text

Rails.root/con g/ application.rb require 'rails/all' Bundler.require(*Rails.groups) module YourApp class Application < Rails::Application end end

Slide 121

Slide 121 text

Rails.root/con g/ application.rb Requires 'rails/all' Requires bundled gems De nes Rails.application

Slide 122

Slide 122 text

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

Slide 123

Slide 123 text

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'

Slide 124

Slide 124 text

*/railtie.rb De nes con gs and initializers, as we have seen already

Slide 125

Slide 125 text

And then, what happens next is... Rails.application.initialize!

Slide 126

Slide 126 text

Rails.application.initialize! (rails/application.rb) module Rails class Application < Engine def initialize!(group=:default) ... run_initializers(group, self) ... ennnd

Slide 127

Slide 127 text

Rails.application.initialize! Calls run_initializers

Slide 128

Slide 128 text

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

Slide 129

Slide 129 text

How the initializers are run? Calls #run method for each Initializer object in the initializers collection

Slide 130

Slide 130 text

Initializer#run (rails/initializable.rb) module Rails module Initializable class Initializer def run(*args) @context.instance_exec(*args, &block) ennnnd

Slide 131

Slide 131 text

Initializer#run It simply instance_execs the stored Proc in some context stored in @context @context is actually the application instance

Slide 132

Slide 132 text

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

Slide 133

Slide 133 text

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

Slide 134

Slide 134 text

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.initial ize method call

Slide 135

Slide 135 text

Who calls Rails::Railtie.initialize? Railtie subclasses such as ActiveRecord::Railtie, ActionPack::Railtle, etc.

Slide 136

Slide 136 text

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

Slide 137

Slide 137 text

Building middleware stack Chapter 4

Slide 138

Slide 138 text

con g.ru run Rails.application

Slide 139

Slide 139 text

run Rails.application With this de nition, the Rack server calls `Rails.application.call(env)`

Slide 140

Slide 140 text

Rails.application responds_to :call Rails.application is_a Rack app

Slide 141

Slide 141 text

Rails.application as a Rack application (railties/lib/rails/applicaiton.rb) module Rails class Application ... def call(env) env["ORIGINAL_FULLPATH"] = build_original_fullpath(env) env["ORIGINAL_SCRIPT_NAME"] = env["SCRIPT_NAME"] super(env) ennnd

Slide 142

Slide 142 text

Rails::Application#call Calls super The super class is Rails::Engine

Slide 143

Slide 143 text

Rails::Engine is also a Rack app (railties/lib/rails/engine.rb) module Rails class Engine ... def call(env) env.merge!(env_config) if env['SCRIPT_NAME'] env.merge! "ROUTES_#{routes.object_id}_SCRIPT_NAME" => env['SCRIPT_NAME'].dup end app.call(env) ennnd

Slide 144

Slide 144 text

Rails::Engine is also a Rack app The call goes to app.call

Slide 145

Slide 145 text

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

Slide 146

Slide 146 text

What's app? app is con g.middleware that contains default_middleware_stack and endpoint

Slide 147

Slide 147 text

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

Slide 148

Slide 148 text

What is Rails::Con guration::MiddlewareStackProxy? (rails/con guration.rb) module Rails module Configuration class MiddlewareStackProxy def initialize @operations = [] ennnnd

Slide 149

Slide 149 text

What is Rails::Con guration::MiddlewareStackProxy? Basically it's a stack that proxies the Rails middleware stack

Slide 150

Slide 150 text

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

Slide 151

Slide 151 text

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

Slide 152

Slide 152 text

What's the endpoint? endpoint = routes (is_a ActionDispatch::Routing::Route Set) by default

Slide 153

Slide 153 text

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"

Slide 154

Slide 154 text

Routes Chapter 5

Slide 155

Slide 155 text

Rails.application.routes Usually written in Rails.root/ con g/routes.rb

Slide 156

Slide 156 text

An example routes.rb (Rails.root/con g/routes.rb) Rails.application.routes.draw do get "/hello" => "foo#bar" end

Slide 157

Slide 157 text

What is routes? Rails.application.routes.class => ActionDispatch::Routing::RouteSet

Slide 158

Slide 158 text

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

Slide 159

Slide 159 text

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

Slide 160

Slide 160 text

What is @router? It's a Journey thing!

Slide 161

Slide 161 text

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

Slide 162

Slide 162 text

De ning routes

Slide 163

Slide 163 text

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

Slide 164

Slide 164 text

routes.draw instance_execs the whole given block with an instance of ActionDispatch::Routing::Mapp er

Slide 165

Slide 165 text

This DSL calls AD::Routing::Mapper#get (Rails.root/con g/routes.rb) Rails.application.routes.draw do get "/hello" => "foo#bar" end

Slide 166

Slide 166 text

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

Slide 167

Slide 167 text

AD::Routing::Mapper#get Mapper#get nally goes to Mapper#add_route

Slide 168

Slide 168 text

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

Slide 169

Slide 169 text

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

Slide 170

Slide 170 text

Mapper#add_route Finally adds a new Journey::Route to routes Makes a Mepper#to_route call

Slide 171

Slide 171 text

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

Slide 172

Slide 172 text

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

Slide 173

Slide 173 text

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

Slide 174

Slide 174 text

to.respond_to?(:call) ?? Possibly An endpoint can be a Rack app or a mounted Engine

Slide 175

Slide 175 text

to.respond_to?(:call) ?? get "/ok" => ->(env) { [200, {}, ["OK"]] }

Slide 176

Slide 176 text

"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

Slide 177

Slide 177 text

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

Slide 178

Slide 178 text

controller.action(action) is a Rack app > FooController.action('bar') => #

Slide 179

Slide 179 text

get "/hello" => "foo#bar" Maps "/hello" to a Proc returned by FooController.action('bar')

Slide 180

Slide 180 text

Resolving routes

Slide 181

Slide 181 text

Calls to the router Rails.application.routes.call(env)

Slide 182

Slide 182 text

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

Slide 183

Slide 183 text

RouteSet#call => Journey::Router#call module ActionDispatch module Routing class RouteSet ... def call(env) @router.call(env) ennnnd

Slide 184

Slide 184 text

Journey::Router#call It's another long journey... Anyway it resolves the route

Slide 185

Slide 185 text

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

Slide 186

Slide 186 text

Controllers and actions Chapter 6

Slide 187

Slide 187 text

What's gonna happen when the server got a Request? controller.action(action).call(en v)

Slide 188

Slide 188 text

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

Slide 189

Slide 189 text

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

Slide 190

Slide 190 text

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

Slide 191

Slide 191 text

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

Slide 192

Slide 192 text

AC::Metal#dispatch Calls AC::Metal#process

Slide 193

Slide 193 text

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

Slide 194

Slide 194 text

Controller#process_action process_action(action_name, *args) is equivalent to send action_name

Slide 195

Slide 195 text

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