First, the basics. According to the spec:
A Rack application is an Ruby object (not a class) that responds to call. It
takes exactly one argument, the environment and returns an Array of exactly
three values: the status, the headers, and the body.
So each component in a rack stack is like a rung in a ladder. An incoming request is stashed inside a hash called the environment, which includes info about the request itself and othert things (see the spec). That environment is passed down the ladder from one component to the next until it gets to the app at the end. The app receives the environment, generates a response, and returns it. Since the app was called by the final rack component, it hands it response back to that component. That component then returns the response to the component which called it, etc, effectively passing it back up the ladder, until it's returned to the user.
Got that? Requests go down the ladder, responses come back up.
Of course, in that description, each component is just passing the environment down and then passing the response back up. If that's all a component did, it would be useless. To be useful, it will have to actually something. Specifically, a given component will do (at least) one of three things:
- Screen the requests. For example, if the component is for authorization, it verifies that the user has entered a valid login. If it's an invalid login, it will return a "failed login" response and never call the next component. If it's a valid login, it will pass the request to the next component - maybe a Rails app.
- Modify the environment before passing it on to the next component. Our authorization component might do this in addition to screening: if there's a valid login, it might set a user object in the environment before passing that to the next component. With this setup, the next component can assume that the user object will always be set whenever it gets a request.
- Modify the response after getting it back from the next component. A silly example would be to translate the response into Japanese.
Notice that each component needs to know what the next component in the chain is, so that it knows who to call. That's why whatever you give to Rack::Builder#use needs to have an
initializemethod that accepts the next component, in addition to a
callmethod that accepts the env.
The application at the end, however, doesn't need to call anybody else; it just needs to take the env as it then stands and generate a response. So whatever you pass to
Rack::Builder::rundoesn't need an
initializemethod; it just needs to respond to
call(env). Even a lambda can do that.
Some pseudocode examples of call methods:
# A component with this call method would be useless. # Still, it's worth remembering that this: def call(env) @next_component.call(env) end # ... is Ruby shorthand for this: def call(env) result = @next_component.call(env) return result end # Instead, we can do something useful on the way in: def call(env) valid_user = contains_valid_login?(env) if valid_user add_current_user_object_to(env) # Next component can rely on having a current_user object @next_component.call(env) else redirect_to_login_page_with_error end end # Or we can do something useful on the way out: def call(env) result = @next_component.call(env) result.translate_to_russian! end