DEV Community

Paweł Pacana
Paweł Pacana

Posted on • Originally published at

Explaining Rack — desugaring Rack::Builder DSL

Yesterday I wrote a post highlighting Basic Auth and how can we protect Rack applications mounted in Rails with it.
Today when discussing some ideas from this post with my colleague, our focus immediately shifted to Rack::Builder.

On one hand Rack interface is simple, fairly constrained and well described in spec. And ships with a linter to help your Rack apps and middleware pass this compliance.

A Rack application is a 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.

class HelloWorld
  def call(env)
    [200, {"Content-Type" => "text/plain"}, ["Hello world!"]]
Enter fullscreen mode Exit fullscreen mode

On the other hand your first exposure to Rack is usually via in Rails application:

# This file is used by Rack-based servers to start the application.

require_relative "config/environment"

run Rails.application
Enter fullscreen mode Exit fullscreen mode

Behind the scenes, this file is eventually passed to Rack::Builder. It is a convenient DSL to compose Rack application out of other Rack applications. In yesterday's blogpost we've seen it being used directly: do
  use Rack::Auth::Basic do |username, password|
    ActiveSupport::SecurityUtils.secure_compare(::Digest::SHA256.hexdigest(username), ::Digest::SHA256.hexdigest(ENV.fetch("DEV_UI_USERNAME"))) &
      ActiveSupport::SecurityUtils.secure_compare(::Digest::SHA256.hexdigest(password), ::Digest::SHA256.hexdigest(ENV.fetch("DEV_UI_PASSWORD")))
  run Sidekiq::Web
Enter fullscreen mode Exit fullscreen mode

Whether you use Rack::Builder directly or via rackup files, you're immediately associating Rack with the use and run DSL.
And that triggered an honest question from my colleague — how does this DSL relate to that rather simple Rack interface?

De-sugaring Rack::Builder DSL

To add even more nuance, some Rack apps are called a middleware. What is a middleware? In simple words — it's a Rack application that wraps another Rack application. It may affect the input passed to the wrapped app. Or it may affect the output if it.

An example of a middleware that makes everything sound more dramatic:

class Dramatize
  def initialize(app)
    @app = app

  def call(env)
    status, headers, body =
    [status, headers, { |x| "#{x}111one!1" }]
Enter fullscreen mode Exit fullscreen mode

A composition of such middleware and our previous sample HelloWorld application with would look like this:


class HelloWorld
  # omitted for brevity

class Dramatize
  # omitted for brevity

use Dramatize
Enter fullscreen mode Exit fullscreen mode

When executed, it would return very dramatic greeting:

$ bundle exec rackup
* Listening on
* Listening on http://[::1]:9292
Use Ctrl-C to stop

$ curl localhost:9292                                                    
Hello world!111one!1⏎ 
Enter fullscreen mode Exit fullscreen mode

Now back to the question that started it all:

How does this DSL relate to that rather simple Rack interface?

The last example of composition via Rack::Builder can be rewritten to avoid some of the DSL:


Enter fullscreen mode Exit fullscreen mode

A single run is needed to tell a Ruby application server what is our Rack application that we'd like to run. The use of use is on the other hand just optional.

If this post got you curious on Rack, a fun way to learn more about it is to check the code of each middleware powering your Rails application:

$ bin/rails middleware
use Webpacker::DevServerProxy
use Honeybadger::Rack::UserInformer
use Honeybadger::Rack::UserFeedback
use Honeybadger::Rack::ErrorNotifier
use Rack::Cors
use ActionDispatch::HostAuthorization
use Rack::Sendfile
use ActionDispatch::Static
use ActionDispatch::Executor
use ActiveSupport::Cache::Strategy::LocalCache::Middleware
use Rack::Runtime
use Rack::MethodOverride
use ActionDispatch::RequestId
use ActionDispatch::RemoteIp
use Rails::Rack::Logger
use ActionDispatch::ShowExceptions
use ActionDispatch::DebugExceptions
use ActionDispatch::ActionableExceptions
use ActionDispatch::Reloader
use ActionDispatch::Callbacks
use ActionDispatch::Cookies
use ActionDispatch::Session::CookieStore
use ActionDispatch::Flash
use ActionDispatch::ContentSecurityPolicy::Middleware
use ActionDispatch::PermissionsPolicy::Middleware
use Rack::Head
use Rack::ConditionalGet
use Rack::ETag
use Rack::TempfileReaper
use Warden::Manager
use Rack::Deflater
use RailsEventStore::Middleware
run MyApp::Application.routes
Enter fullscreen mode Exit fullscreen mode

Happy learning!

Top comments (0)