Absolutamente. Para ver un ejemplo de esto recomiendo descargar la gema Monk, descrita aquí:

Https://github.com/monkrb/monk

Puede 'instalar gema' a través de rubygems.org.Una vez que tenga la gema, genere una aplicación de ejemplo utilizando las instrucciones enlazadas anteriormente.

Tenga en cuenta que no tiene que usar Monk para su desarrollo real a menos que lo desee (de hecho, creo que puede no ser actual). El punto es ver cómo puede estructurar fácilmente su aplicación en el estilo MVC (con archivos de ruta separados similares al controlador) si lo desea.

Es bastante simple si nos fijamos en cómo Monk lo maneja, principalmente una cuestión de requerir archivos en directorios separados, algo así como (tendrá que definir root_path):

Dir[root_path("app/**/*.rb")].each do |file|
    require file
end

Haga una búsqueda en Google de "Sinatra boilerplate" para obtener algunas ideas sobre cómo otros están diseñando sus aplicaciones Sinatra. A partir de eso, probablemente pueda encontrar uno que se adapte a sus necesidades o simplemente hacer el suyo propio. No es muy difícil de hacer. A medida que desarrolles más aplicaciones Sinatra, puedes agregarlas a tu plantilla.

Esto es lo que hice y utilicé para todos mis proyectos:

Https://github.com/rziehl/sinatra-boilerplate

Sé que esta es una consulta antigua, pero todavía no puedo creer que nadie mencionó Padrino Puede usarlo como un marco sobre Sinatra, o por partes agregando solo las gemas que le interesen. ¡Patea diez culos!

Mi enfoque para alojar diferentes proyectos en el mismo sitio es usar sinatra/namespace de tal manera:

Servidor.rb

require "sinatra"
require "sinatra/namespace"

if [ENV["LOGNAME"], ENV["USER"]] == [nil, "naki"]
    require "sinatra/reloader"
    register Sinatra::Reloader
    set :port, 8719
else
    set :environment, :production
end

for server in Dir.glob "server_*.rb"
    require_relative server
end

get "/" do
    "this route is useless"
end

Server_someproject.rb

module SomeProject
    def self.foo bar
       ...
    end
    ...
end

namespace "/someproject" do
    set :views, settings.root
    get "" do
        redirect request.env["REQUEST_PATH"] + "/"
    end
    get "/" do
        haml :view_someproject
    end
    post "/foo" do
        ...
        SomeProject.foo ...
    end
end

View_someproject.haml

!!!
%html
    ...

Otro detalle sobre los subproyectos que utilicé fue agregar sus nombres, descripción y rutas a algún tipo de variable global, que es utilizada por "/" para hacer una página de inicio de guía, pero no tengo un fragmento en este momento.

Leyendo los documentos aquí:

Extensiones de Sinatra

Parece que Sinatra le permite descomponer su aplicación en módulos Ruby, que se pueden extraer a través del método "register" o métodos "helpers" de Sinatra, así:

Ayudantes.rb

require 'sinatra/base'

module Sinatra
  module Sample
    module Helpers

      def require_logged_in()
        redirect('/login') unless session[:authenticated]
      end

    end
  end
end

Enrutamiento/foos.rb

require 'sinatra/base'

module Sinatra
  module Sample
    module Routing
      module Foos

        def self.registered(app)           
          app.get '/foos/:id' do
            # invoke a helper
            require_logged_in

            # load a foo, or whatever
            erb :foos_view, :locals => { :foo => some_loaded_foo }
          end   
        end  

      end
    end     
  end
end

App.rb

#!/usr/bin/env ruby

require 'sinatra'

require_relative 'routing/foos'

class SampleApp < Sinatra::Base

  helpers Sinatra::Sample::Helpers

  register Sinatra::Sample::Routing::Foos

end

Cuando Monk no trabajaba para mí, empecé a trabajar en plantillas yo mismo.

Si lo piensas bien, no hay nada especial en vincular un conjunto de archivos. La filosofía monk me fue explicada a principios de 2011 durante RedDotRubyConf y me han dicho específicamente que es realmente opcional usarla, especialmente ahora que apenas se mantiene.

Este es un buen comienzo para aquellos que quieren usar ActiveRecord:

Simple Sinatra MVC

Https://github.com/katgironpe/simple-sinatra-mvc

La clave para la modularidad en Sinatra para proyectos más grandes es aprender a usar las herramientas subyacentes.

SitePoint tiene un muy buen tutorial desde donde se pueden ver aplicaciones modulares de Sinatra y helpers. Sin embargo tenéis que prestar la atención especial a un detalle importante. Mantiene varias aplicaciones Sinatra y las monta con Rackup. Una vez que sepa cómo escribir una aplicación básica, mire config.ru archivo de ese tutorial y observar cómo montan Sinatra independiente aplicaciones.

Una vez que aprendas a ejecutar Sinatra con Rack, se abrirá un nuevo mundo de estrategias de modularidad. Obviamente, esto invita a probar algo realmente útil: ahora puede confiar en tener gemas individuales para cada subaplicación , lo que podría permitirle versionar fácilmente sus módulos.

No subestime el poder de usar módulos de gemas para su aplicación. Puede probar fácilmente los cambios experimentales en un entorno bien delimitado e implementarlos fácilmente. Igualmente fácil de volver atrás si algo sale mal.

Hay mil formas de organizar tu código, por lo que no estaría de más intentar conseguir un diseño similar a Rails. Sin embargo, también hay algunos grandes mensajes acerca de cómo personalizar su propia estructura. Esa publicación cubre otras necesidades frecuentes de la mayoría de los desarrolladores web.

Si tienes tiempo, te animo a aprender más sobre Rack, el terreno común para cualquier aplicación web basada en Ruby. Podría tener un impacto mucho menor en cómo haces tu trabajo, pero siempre hay ciertas tareas que la mayoría de las personas hacen en sus aplicaciones que se ajustan mejor como un middleware de rack.