Rails%203%20In%20Action

522 CHAPTER 18 Rack-based applications
You’ve learned the basics of how a Rack application works and gained an understanding
that your Rails application is a bigger version of this little application you’ve
written. There’s much more to Rack than providing this abstraction for the underlying
request/response cycle. For example, you can build more complex apps with logic
for one part of the application in one class and additional logic in another.
One other feature of Rack is the ability to build applications by combining smaller
applications into a larger one. You saw this with Rails when you used the mount
method in your application’s config/routes.rb to mount the engine you developed in
chapter 17. Let’s see how you can do this with Rack.
18.2 Building bigger Rack applications
Your basic Rack application quickly outgrew the lambda shell you placed it in, and so
you moved the logic in it into a class and added some more. With the class, you’re able
to define a call method on it, which then returns the response that Rack needs. The
class allows you to cleanly write a more complex Rack application than a lambda would.
So what happens now if you outgrow a class? Well, you can abstract the function of
your application into multiple classes and build a Rack application using those classes.
The structure is not unlike the controller structure you have in a Rails application,
because it will have separate classes that are responsible for different things.
In your new Rack application, you’ll have two classes that perform separate tasks,
but are still running on the same instance of the server. The first class is going to be
your Heartbeat::Application class, and the second one will provide two forms, each
with one button: one for success and one for failure. These forms will then submit to
the actions provided within the Heartbeat::Application class, which will demonstrate
how you can get your classes to talk to each other.
18.2.1 You’re breaking up
Now that your Rack application is getting more complex, you’re going to break it out
into three files. The first file will be the Heartbeat::Application class, the second
will be a new class called Heartbeat::TestApplication, and the third will be the
Rackup file that will be responsible for combining these two classes into one glorious
application.
Let’s begin by separating out your application and the Rackup file into two separate
files. In a new directory at lib/heartbeat.rb, add the code shown in the following
listing to lib/heartbeat/application.rb.
Listing 18.2 lib/heartbeat/application.rb
module Heartbeat
class Application
def self.call(env)
default_headers = { "Content-Type" => "text/plain"}
if env["PATH_INFO"] =~ /200/
body = "Success!"