Rails%203%20In%20Action

536 CHAPTER 18 Rack-based applications
In this request, the ActionDispatch::Static middleware first checks for the presence
of public/projects.html, which would be there if you had cached the page.
Because it’s not there, the request goes through the rest of the middleware stack
being passed along. When it gets to ActionDispatch::Best::StandardsSupport, this
middleware sets the X-UA-Compatible header and passes along the request to the
application, which then serves the request like normal.
Let’s dive into exactly how ActionDispatch::Static works.
18.4.2 Investigating ActionDispatch::Static
The ActionDispatch::Static class is responsible for serving static requests in the
development environment for your application. The code for this piece of middleware
can be found in the actionpack gem, which you can view by opening the path provided
by the command bundle show actionpack in your editor. The file that defines the
ActionDispatch::Static middleware can be found at lib/action_dispatch/
middleware/static.rb. The first 10 lines in this file are shown inthe following listing.
Listing 18.10 Listing 18.10 lib/action_dispatch/middleware/static.rb
require 'rack/utils'
module ActionDispatch
class Static
FILE_METHODS = %w(GET HEAD).freeze
def initialize(app, root)
@app = app
@file_server = ::Rack::File.new(root)
end
The first line requires the rack/utilsfile, which contains the Rack::Utils module this
file references a little later on. The next three lines define the ActionDispatch
::Static class and a constant called FILE_METHODS. Finally, this middleware defines
the initialize method, which takes two arguments, an app and a root. This method
then assigns the app argument to the @app variable so that it can be accessed in methods
called after this point. The root variable is passed to a call to ::Rack::File.new 7
which is then assigned to the @file_server variable. The Rack::File class is actually
a Rack application too, as you’ll see later.
So why does this middleware begin in this particular way, and what is app? Well, app
is the next piece of middleware in the stack that you can pass requests to if you wish.
You’ll see this app variable used later. The instance of your middleware is then cached
by the Rails server so it can call the call method on it when a request comes into the
stack. The call method in this middleware begins with this:
7 Not-well-known Ruby fact: the double colon (::) of ::Rack::File represents a top-level class, meaning that
Ruby will get the Rack::File class defined at the top level of your application, rather than one (potentially)
within the current class or module.