Libraries and Middleware to work with in Sinatra

Sinatra::Base - Middleware, Libraries, and Modular Apps

Sinatra is a free and open source programming web application library and space explicit language written in Ruby. It is an option in contrast to other Ruby web application systems like Ruby on Rails, Merb, Nitro, and Camping. It is reliant upon the Rack web server interface. Characterizing your application at the high-level functions admirably for miniature applications has significant disadvantages while building reusable parts, for example, Rack middleware, Rails metal, straightforward libraries with a server part, or even Sinatra expansions. 

The high level expects a miniature application style setup (e.g., a solitary application document, ./public and ./sees indexes, logging, exemption detail page, etc.). That is where Sinatra::Base becomes an integral factor:

require 'sinatra/base'

class MyApp < Sinatra::Base
  set :sessions, true
  set :foo, 'bar'

  get '/' do
    'Hello world!'
  end
end

 

The strategies accessible to Sinatra::Base subclasses are the same as those accessible through the high-level DSL. Most high-level applications can be changed over entirely to Sinatra::Base parts with two alterations:

✴️Your document ought to require Sinatra/base rather than Sinatra; in any case, Sinatra's DSL techniques are all brought into the primary namespace.

✴️Put your application's courses, blunder controllers, channels, and choices in a subclass of Sinatra::Base.

Sinatra::Base is a clean canvas. Most choices are handicapped, as a matter of course, incorporating the inherent server. See Configuring Settings for subtleties on accessible options and their way of behaving. If you need to conduct more like when you characterize your application at the high level (otherwise called Classic style), you can subclass Sinatra::Application:

require 'sinatra/base'

class MyApp < Sinatra::Application
  get '/' do
    'Hello world!'
  end
end

Modular vs. Classic Style

As opposed to regular conviction, the excellent style checks out. If it suits your application, you don't need to change to a measured application.

The fundamental hindrance of utilizing the exemplary style instead of the measured tone is that you will just have one Sinatra application for every Ruby cycle. On the off chance that you intend to utilize multiple, change to the secluded style. There is not an obvious explanation you can't blend the measured and the suitable techniques.

On the off chance that you are changing from one style to the next, you ought to know about somewhat unique default settings:

Serving a Modular Application

There are two typical choices for beginning a secluded application, effectively starting with run!: 🧑‍💻

# my_app.rb
require 'sinatra/base'

class MyApp < Sinatra::Base
  # ... app code here ...

  # start the server if ruby file executed directly
  run! if app_file == $0
end

 

Utilizing a Classic Style Application with a config.ru

Compose your application document:

# app.rb
require 'sinatra'

get '/' do
  'Hello world!'
end

When to Utilize a config.ru?

A config.ru document is suggested if:

🔅You need to send with an alternate Rack controller (Passenger, Unicorn, Heroku, … ).

🔅You need to utilize more than one subclass of Sinatra::Base.

🔅You need to use Sinatra for middleware and not as an endpoint.

There is a compelling reason to change to a config.ru because you switched to the particular style, and you don't need to involve the secluded kind for running with a config.ru.

Involving Sinatra as Middleware 

In addition to the fact that Sinatra is ready to utilize other Rack middleware, any Sinatra application can, like this, be included front of any Rack endpoint as middleware itself. This endpoint could be another Sinatra application or some other Rack-based application (Rails/Hanami/Roda/… ):

require 'sinatra/base'

class LoginScreen < Sinatra::Base
  enable :sessions

  get('/login') { haml :login }

  post('/login') do
    if params['name'] == 'admin' && params['password'] == 'admin'
      session['user_name'] = params['name']
    else
      redirect '/login'
    end
  end
end

class MyApp < Sinatra::Base
  # middleware will run before filters
  use LoginScreen

  before do
    unless session['user_name']
      halt "Access denied, please <a href='/login'>login</a>."
    end
  end

  get('/') { "Hello #{session['user_name']}." }
end

Dynamic Application Creation 🎯

At times you need to make new applications at runtime without doling out them to a steady. You can do this with Sinatra.new:

require 'sinatra/base'
my_app = Sinatra.new { get('/') { "hi" } }
my_app.run!

It takes the application to acquire from as a discretionary contention:

# config.ru (run with rackup)
require 'sinatra/base'

controller = Sinatra.new do
  enable :logging
  helpers MyHelpers
end

map('/a') do
  run Sinatra.new(controller) { get('/') { 'a' } }
end

map('/b') do
  run Sinatra.new(controller) { get('/') { 'b' } }
end

 

This is particularly valuable for testing Sinatra expansions or involving Sinatra in your library.

This likewise makes involving Sinatra as middleware very simple:

require 'sinatra/base'

use Sinatra do
  get('/') { ... }
end

run RailsProject::Application

Rack Middleware

Sinatra rides on Rack, a minor standard connection point for Ruby web systems. One of Rack's most fascinating abilities for application engineers is support for "middleware" - parts that sit between the server and your application, observing and additionally controlling the HTTP demand/reaction to give different everyday usefulness.

Sinatra makes building Rack middleware pipelines a snap through a high-level use strategy:

require 'sinatra'
require 'my_custom_middleware'

use Rack::Lint
use MyCustomMiddleware

get '/hello' do
  'Hello World'
end

 

The purpose semantics are indistinguishable from those characterized for the Rack::Builder DSL (most often utilized from rackup records). For instance, the utilization technique acknowledges numerous/variable args as well as blocks:

use Rack::Auth::Basic do |username, password|
  username == 'admin' && password == 'secret'
end

 

Rack is disseminated with an assortment of standard middleware for logging, troubleshooting, URL directing, validation, and taking care of. Sinatra utilizes many of these parts naturally founded on the design, so you ordinarily don't need to use them expressly.

You can find valuable middleware in rack, rack-contrib, or the Rack wiki.

Frequently Asked Questions ❓

Why do we utilize Sinatra rather than rails?

Sinatra is considerably more lightweight, needs fewer assets, and does fewer things out of the crate. Rails, then again, is loaded with highlights, accompanies a lot of code, and makes it extremely simple to fabricate complex web applications in a limited time, in the event you know how to utilize it.

What is the Sinatra system?

Sinatra is a free and open source programming web application library and space explicit language written in Ruby.

What is Sinatra :: Base?

Sinatra::Base is the Sinatra without designation.

Is flask like Sinatra?

Very much like Flask, Sinatra is perfect for straightforward applications. The actual Sinatra application is just 4 LOC in a solitary Ruby source document. Sinatra is utilized rather than libraries like Ruby on Rails for a similar explanation as Flask - you can begin little and extend the application depending on the situation.

What is Rack middleware?

You can allude rack middleware as a bit of part that helps with the execution of an undertaking. For instance, You can imagine different middleware doing various cycles like logging and reserving.

Conclusion

Sinatra is a free and open source programming web application library and space explicit language written in Ruby. It is an option in contrast to other Ruby web application systems like Ruby on Rails, Merb, Nitro, and Camping. It is subject to the Rack web server interface.

Sinatra::Base is the Sinatra without designation; it is a clean canvas. Most choices are handicapped, as a matter of course, incorporating the inherent server. 

Refer to our Guided Path on Coding Ninjas Studio to upskill yourself in pygame, Competitive Programming, JavaScript, System Design, and many more! If you want to test your competency in coding, you may check out the mock test series and participate in the contests hosted on Coding Ninjas Studio! But suppose you have just started your learning process and are looking for questions asked by tech giants like Amazon, Microsoft, Uber, etc. In that case, you must look at the problems, interview experiences, and interview bundle for placement preparations.

Nevertheless, you may consider our paid courses to give your career an edge over others!

Do upvote our blogs if you find them helpful and engaging!

Happy Learning!