class Racket::Utils::Application::HandlerStack

Class used for building a proper Rack application.

Attributes

stack[R]

Public Class Methods

new(options) click to toggle source
# File lib/racket/utils/application/handler_stack.rb, line 54
def initialize(options)
  @stack = Rack::Builder.new
  @options = OpenStruct.new(options)
  build
end
service(_options = {}) click to toggle source

Returns a service proc that can be used by the registry.

@param [Hash] _options (unused) @return [Proc]

# File lib/racket/utils/application/handler_stack.rb, line 32
def self.service(_options = {})
  lambda do |reg|
    settings = reg.application_settings

    options = {
      default_content_type:       settings.default_content_type,
      default_controller_helpers: settings.default_controller_helpers,
      dev_mode:                   settings.mode == :dev,
      logger:                     reg.application_logger,
      middleware:                 settings.middleware,
      plugins:                    settings.plugins,
      router:                     reg.router,
      session_handler:            settings.session_handler,
      static_server:              reg.static_server,
      utils:                      reg.utils,
      warmup_urls:                settings.warmup_urls
    }

    new(options).stack
  end
end

Private Instance Methods

add_middleware(middleware) click to toggle source

Add middleware to the builder.

# File lib/racket/utils/application/handler_stack.rb, line 73
def add_middleware(middleware)
  expand_middleware_list(middleware)
  middleware.each do |ware|
    klass, opts = ware
    @options.logger.inform_dev("Loading middleware #{klass} with settings #{opts.inspect}.")
    @stack.use(*ware)
  end
end
add_warmup_hook() click to toggle source

Add a list of urls to visit on startup

# File lib/racket/utils/application/handler_stack.rb, line 83
def add_warmup_hook
  warmup_urls = @options.warmup_urls
  return if warmup_urls.empty?
  @stack.warmup do |app|
    client = Rack::MockRequest.new(app)
    visit_warmup_urls(client, warmup_urls)
  end
end
application_proc() click to toggle source

Returns a lambda that represenents that application flow.

# File lib/racket/utils/application/handler_stack.rb, line 93
def application_proc
  if (static_server = @options.static_server)
    application_proc_with_static_server(static_server)
  else
    application_proc_without_static_server
  end
end
application_proc_with_static_server(static_server) click to toggle source
# File lib/racket/utils/application/handler_stack.rb, line 101
def application_proc_with_static_server(static_server)
  router = @options.router
  lambda do |env|
    static_result = static_server.call(env)
    return static_result if static_result && static_result.first < 400
    router.route(env)
  end
end
application_proc_without_static_server() click to toggle source
# File lib/racket/utils/application/handler_stack.rb, line 110
def application_proc_without_static_server
  router = @options.router
  ->(env) { router.route(env) }
end
build() click to toggle source

Builds a Rack application representing Racket.

@return [Proc]

# File lib/racket/utils/application/handler_stack.rb, line 65
def build
  init_plugins
  add_warmup_hook
  add_middleware(@options.middleware)
  @stack.run(application_proc)
end
expand_middleware_list(middleware) click to toggle source

Expands middleware list based on application settings.

# File lib/racket/utils/application/handler_stack.rb, line 116
def expand_middleware_list(middleware)
  session_handler = @options.session_handler
  default_content_type = @options.default_content_type
  middleware.unshift(session_handler) if session_handler
  middleware.unshift([Rack::ContentType, default_content_type]) if
    default_content_type
  middleware.unshift([Rack::ShowExceptions]) if @options.dev_mode
end
get_plugin_instance(plugin, settings) click to toggle source

Returns an instance of a specific plugin.

@param [Symbol] plugin @param [Hash|nil] settings @return [Object] An instance of the requested plugin class

# File lib/racket/utils/application/handler_stack.rb, line 130
def get_plugin_instance(plugin, settings)
  @options.utils.safe_require("racket/plugins/#{plugin}.rb")
  # TODO: Allow custom plugins dir as well
  klass =
    Racket::Plugins.const_get(plugin.to_s.split('_').collect(&:capitalize).join.to_sym)
  klass.new(settings)
end
init_plugins() click to toggle source

Initializes plugins.

# File lib/racket/utils/application/handler_stack.rb, line 139
def init_plugins
  @options.plugins.each do |plugin_info|
    plugin_instance = get_plugin_instance(*plugin_info)
    run_plugin_hooks(plugin_instance)
    # TODO: Store plugin instance somewhere in application settings
  end
end
run_plugin_hooks(plugin_obj) click to toggle source

Runs plugin hooks.

# File lib/racket/utils/application/handler_stack.rb, line 148
def run_plugin_hooks(plugin_obj)
  @options.middleware.concat(plugin_obj.middleware)
  @options.default_controller_helpers.concat(plugin_obj.default_controller_helpers)
end
visit_warmup_urls(client, urls) click to toggle source

Visits a list of warmup URLs.

# File lib/racket/utils/application/handler_stack.rb, line 154
def visit_warmup_urls(client, urls)
  urls.each do |url|
    @options.logger.inform_dev("Visiting warmup url #{url}.")
    client.get(url)
  end
end