Rails%203%20In%20Action

Building Rack applications
it back up through the stack to Rack, and then Rack will pass
it back to the server, which will finally pass it back to the
browser. All of this happens in a lightning quick fashion.
Separating Rack from Rails not only reduces bloat in the
framework, but also provides a common interface that other
frameworks can use. By standardizing the request/response
cycle, applications that are built on top of Rack can interact
with one another. In this chapter, you’ll see how you can do
this by making your Rails application work with applications
built using Rack, but not Rails.
You’ll build some Rack applications in this chapter that
aren’t Rails applications but will work just as seamlessly.
You’ll learn how Rack provides the request/response cycle
underneath Rails and other Ruby frameworks, and learn how
to build your own small, lightweight Rack-based applications.
With these lightweight applications crafted, you’ll then
create one more application that will re-implement the tickets
API functionality you first created in chapter 13, using
another Rack-based web framework called Sinatra. You’ll
then mount this Sinatra application inside your Rails appli-
cation using methods that Rails provides. This will provide an apt example of how
you’re able to interact with classes from your Rails application from within a mounted
Rack application.
Finally, we’ll take a look at middleware within both the Rack and Rails stacks, and
you’ll learn how to use it to your advantage to manipulate requests coming into your
application.
All Rack-based applications work the same way. You request a URL from the application,
and it sends back a response. But it’s what goes on between that request and
the response that’s the most interesting part. Let’s create a basic Rack application now
so that you can understand the basics.
18.1 Building Rack applications
Browser
Web Server
Rack standardizes the way an application receives requests across all the Ruby frameworks.
With this standardization, you know that any application purporting to be a
Rack application is going to have a standard way for you to send requests to it and a
standard way of receiving responses.
You’re going to build a basic Rack application so that you can learn about the
underlying architecture for requests and responses found in Rails and other Ruby
frameworks. With this knowledge, you’ll be able to build lightweight Rack applications
that you can hook into your Rails stack, or even Rack middleware.
When you’re content with the first application, you’ll create another and then
make them work together as one big application. First things first, though.
Rack
Application Stack
Middleware
...
Middleware
Application
517
Figure 18.1 Application
request through the stack