Class: Hanami::ApplicationConfiguration

#adapter(options) ⇒ `Object` #adapter ⇒ `Hash`

Adapter configuration. The application will instantiate adapter instance based on this configuration.

The given options must have key pairs :type and :uri If it isn’t, at the runtime the framework will raise a ArgumentError.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      adapter :sql, 'sqlite3://uri'
    end
  end
end

Bookshelf::Application.configuration.adapter
  # => [:sql, 'sqlite3://uri']

Overloads:

#adapter(options) ⇒ Object

Sets the given type and uri
Parameters:
- options (Hash) —
  
  a set of options for adapter
#adapter ⇒ Hash

Gets the value
Returns:
- (Hash) —
  
  adapter options

See Also:

Since:

0.2.0

Source: | on GitHub

def adapter(*options)
  if !options.empty?
    @adapter = options
  else
    @adapter
  end
end

#assets ⇒ `Hanami::Config::Assets`

The application will serve the static assets under these directories.

By default it’s equal to the public/ directory under the application root.

Otherwise, you can add different relatives paths under root.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.assets
  # => #<Pathname:/root/path/public>

Adding new assets paths

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      assets do
        sources << [
          'vendor/assets'
        ]
      end
    end
  end
end

Bookshelf::Application.configuration.assets
  # => #<Hanami::Config::Assets @root=#<Pathname:/root/path/assets>, @paths=["public"]>

Gets the value

Returns:

(Hanami::Config::Assets) —

assets root

Since:

0.1.0

Source: | on GitHub

def assets(&blk)
  if @assets
    @assets.__add(&blk)
  else
    @assets ||= Config::FrameworkConfiguration.new(&blk)
  end
end

#body_parsers(parsers) ⇒ `Object` #body_parsers ⇒ `Array`

Body parsing configuration.

Specify a set of parsers for specific mime types that your application will use. This method will return the application’s parsers which you can use to add existing and new custom parsers for your application to use.

By default it’s an empty Array

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.body_parsers
  # => []

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      body_parsers :json, XmlParser.new
    end
  end
end

Bookshelf::Application.configuration.body_parsers
  # => [:json, XmlParser.new]

Setting a new value after one is set.

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      body_parsers :json
      body_parsers XmlParser.new
    end
  end
end

Bookshelf::Application.configuration.body_parsers
  # => [XmlParser.new]

Overloads:

#body_parsers(parsers) ⇒ Object

Specify a set of body parsers.
Parameters:
- parsers (Array) —
  
  the body parser definitions
#body_parsers ⇒ Array

Gets the value
Returns:
- (Array) —
  
  the set of parsers

Since:

0.2.0

Source: | on GitHub

def body_parsers(*parsers)
  if parsers.empty?
    @body_parsers ||= []
  else
    @body_parsers = parsers
  end
end

#controller ⇒ `Hanami::Config::FrameworkConfiguration`

It lazily collects all the low level settings for Hanami::Controller’s configuration and applies them when the application is loaded.

NOTE: This forwards all the configurations to Hanami::Controller, without checking them. Before to use this feature, please have a look at the current Hanami::Controller version installed.

NOTE: This may override some configurations of your application.

Examples:

Define a setting

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      controller.default_request_format :json
    end
  end
end

Override a setting

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      handle_exceptions            false
      controller.handle_exceptions true
    end
  end
end

# Exceptions will be handled

Returns:

(Hanami::Config::FrameworkConfiguration) —

the configuration

See Also:

Since:

0.2.0

Source: | on GitHub

def controller
  @controller ||= Config::FrameworkConfiguration.new
end

#controller_pattern(value) ⇒ `Object` #controller_pattern ⇒ `String`

Defines a relative pattern to find controllers.

By default this equals to "Controllers::%{controller}::%{action}" That means controllers must be structured like this: Bookshelf::Controllers::Dashboard::Index, where Bookshelf is the application module, Controllers is the first value specified in the pattern, Dashboard the controller and Index the action.

This pattern MUST always contain "%{controller}" and %{action}. This pattern SHOULD be used accordingly to #view_pattern value.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      routes do
        get '/', to: 'dashboard#index'
      end
    end
  end

  module Controllers::Dashboard
    class Index
      include Bookshelf::Action

      def call(params)
        # ...
      end
    end
  end
end

Bookshelf::Application.configuration.controller_pattern
  # => "Controllers::%{controller}::%{action}"

# All the controllers MUST live under Bookshelf::Controllers

# GET '/' # => Bookshelf::Controllers::Dashboard::Index

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      controller_pattern "%{controller}Controller::%{action}"

      routes do
        get '/', to: 'dashboard#index'
      end
    end
  end

  module DashboardController
    class Index
      include Bookshelf::Action

      def call(params)
      end
    end
  end
end

Bookshelf::Application.configuration.controller_pattern
  # => "%{controller}Controller::%{action}"

# All the controllers are directly under the Bookshelf module

# GET '/' # => Bookshelf::DashboardController::Index

Setting the value for a top level name structure

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      controller_pattern "%{controller}Controller::%{action}"

      routes do
        get '/', to: 'dashboard#index'
      end
    end
  end
end

module DashboardController
  class Index
    include Bookshelf::Action

    def call(params)
    end
  end
end

Bookshelf::Application.configuration.controller_pattern
  # => "%{controller}Controller::%{action}"

# All the controllers are at the top level namespace

# GET '/' # => DashboardController::Index

Overloads:

#controller_pattern(value) ⇒ Object

Sets the given value
Parameters:
- value (String) —
  
  the controller pattern
#controller_pattern ⇒ String

Gets the value
Returns:
- (String)

See Also:

Since:

0.1.0

Source: | on GitHub

def controller_pattern(value = nil)
  if value
    @controller_pattern = value
  else
    @controller_pattern ||= 'Controllers::%{controller}::%{action}'
  end
end

#cookies(options) ⇒ `Object` #cookies ⇒ `Hanami::Config::Cookies`

Configure cookies Enable cookies (disabled by default).

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.cookies
  # => #<Hanami::Config::Cookies:0x0000000329f880 @options={}, @default_options={:httponly=>true, :secure=>false}>

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      cookies domain: 'hanamirb.org'
    end
  end
end

Bookshelf::Application.configuration.cookies
  # => #<Hanami::Config::Cookies:0x0000000329f880 @options={:domain=>'hanamirb.org'}, @default_options={:domain=>'hanamirb.org', :httponly=>true, :secure=>false}>

Overloads:

#cookies(options) ⇒ Object

Sets the given value with their options.
Parameters:
- options (Hash, TrueClass, FalseClass)
#cookies ⇒ Hanami::Config::Cookies

Gets the value.
Returns:
- (Hanami::Config::Cookies)

Since:

0.1.0

Source: | on GitHub

def cookies(options = nil)
  if options.nil?
    @cookies ||= Config::Cookies.new(self, options)
  else
    @cookies = Config::Cookies.new(self, options)
  end
end

#default_request_format(format) ⇒ `Object` #default_request_format ⇒ `Symbol`

Set a format as default fallback for all the requests without a strict requirement for the mime type.

The given format must be coercible to a symbol, and be a valid mime type alias. If it isn’t, at the runtime the framework will raise a Hanami::Controller::UnknownFormatError.

By default this value is :html.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.default_request_format # => :html

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      default_request_format :json
    end
  end
end

Bookshelf::Application.configuration.default_request_format # => :json

Overloads:

#default_request_format(format) ⇒ Object

Sets the given value
Parameters:
- format (#to_sym) —
  
  the symbol format
Raises:
- (TypeError) —
  
  if it cannot be coerced to a symbol
#default_request_format ⇒ Symbol

Gets the value
Returns:
- (Symbol)

See Also:

Since:

0.5.0

Source: | on GitHub

def default_request_format(format = nil)
  if format
    @default_request_format = Utils::Kernel.Symbol(format)
  else
    @default_request_format || :html
  end
end

#default_response_format(format) ⇒ `Object` #default_response_format ⇒ `Symbol`^?

Set a format to be used for all responses regardless of the request type.

The given format must be coercible to a symbol, and be a valid mime type alias. If it isn’t, at the runtime the framework will raise a Hanami::Controller::UnknownFormatError.

By default this value is :html.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.default_response_format # => :html

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      default_response_format :json
    end
  end
end

Bookshelf::Application.configuration.default_response_format # => :json

Overloads:

#default_response_format(format) ⇒ Object

Sets the given value
Parameters:
- format (#to_sym) —
  
  the symbol format
Raises:
- (TypeError) —
  
  if it cannot be coerced to a symbol
#default_response_format ⇒ Symbol^?

Gets the value
Returns:
- (Symbol, nil)

See Also:

Since:

0.5.0

Source: | on GitHub

def default_response_format(format = nil)
  if format
    @default_response_format = Utils::Kernel.Symbol(format)
  else
    @default_response_format
  end
end

#force_ssl(value = nil) ⇒ `Boolean`

Force ssl redirection if http scheme is set

Returns:

(Boolean)

See Also:

Since:

0.4.0

Source: | on GitHub

def force_ssl(value = nil)
  if value
    @force_ssl = value
  else
    @force_ssl || false
  end
end

#handle_exceptions(value) ⇒ `Object` #handle_exceptions ⇒ `TrueClass`, `FalseClass`

Decide if handle exceptions with an HTTP status or let them uncaught

If this value is set to true, the configured exceptions will return the specified HTTP status, the rest of them with 500.

If this value is set to false, the exceptions won’t be caught.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Enabled (default)

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      routes do
        get '/error', to: 'error#index'
      end
    end

    load!
  end

  module Controllers::Error
    class Index
      include Bookshelf::Action

      def call(params)
        raise ArgumentError
      end
    end
  end
end

# GET '/error' # => 500 - Internal Server Error

Disabled

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      handle_exceptions false

      routes do
        get '/error', to: 'error#index'
      end
    end

    load!
  end

  module Controllers::Error
    class Index
      include Bookshelf::Action

      def call(params)
        raise ArgumentError
      end
    end
  end
end

# GET '/error' # => raises ArgumentError

Overloads:

#handle_exceptions(value) ⇒ Object

Sets the given value
Parameters:
- value (TrueClass, FalseClass) —
  
  true or false, default to true
#handle_exceptions ⇒ TrueClass, FalseClass

Gets the value
Returns:
- (TrueClass, FalseClass)

See Also:

Since:

0.2.0

Source: | on GitHub

def handle_exceptions(value = nil)
  if value.nil?
    @handle_exceptions
  else
    @handle_exceptions = value
  end
end

#host(value) ⇒ `Object` #scheme ⇒ `String`

The URI host for this application. This is used by the router helpers to generate absolute URLs.

By default this value is "localhost".

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.host # => "localhost"

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      host 'bookshelf.org'
    end
  end
end

Bookshelf::Application.configuration.host # => "bookshelf.org"

Overloads:

#host(value) ⇒ Object

Sets the given value
Parameters:
- value (String) —
  
  the URI host
#scheme ⇒ String

Gets the value
Returns:
- (String)

See Also:

Since:

0.1.0

Source: | on GitHub

def host(value = nil)
  if value
    @host = value
  else
    @host ||= @env.host
  end
end

#layout(value) ⇒ `Object` #layout ⇒ `Symbol`^?

A Hanami::Layout for this application

By default it’s nil.

It accepts a Symbol as layout name. When the application is loaded, it will lookup for the corresponding class.

All the views will use this layout, unless otherwise specified.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.layout # => nil

# All the views will render without a layout

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      layout :application
    end
  end

  module Views
    module Dashboard
      class Index
        include Bookshelf::Views
      end

      class JsonIndex < Index
        layout nil
      end
    end
  end
end

Bookshelf::Application.configuration.namespace layout => :application

# All the views will use Bookshelf::Views::ApplicationLayout, unless
# they set a different value.

Bookshelf::Views::Dashboard::Index.layout
  # => Bookshelf::Views::ApplicationLayout

Bookshelf::Views::Dashboard::JsonIndex.layout
  # => Hanami::View::Rendering::NullLayout

Overloads:

#layout(value) ⇒ Object

Sets the given value
Parameters:
- value (Symbol) —
  
  the layout name
#layout ⇒ Symbol^?

Gets the value
Returns:
- (Symbol, nil) —
  
  the layout name

See Also:

Since:

0.1.0

Source: | on GitHub

def layout(value = nil)
  if value
    @layout = value
  else
    @layout
  end
end

#load_paths ⇒ `Hanami::Config::LoadPaths`

Application load paths The application will recursively load all the Ruby files under these paths.

By default it’s empty in order to allow developers to decide their own app structure.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.load_paths
  # => #<Hanami::Config::LoadPaths:0x007ff4fa212310 @paths=[]>

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      load_paths << [
        'app/controllers',
        'app/views
      ]
    end
  end
end

Bookshelf::Application.configuration.assets
  # => #<Hanami::Config::LoadPaths:0x007fe3a20b18e0 @paths=[["app/controllers", "app/views"]]>

Returns:

(Hanami::Config::LoadPaths) —

a set of load paths

See Also:

Since:

0.1.0

Source: | on GitHub

def load_paths
  @load_paths ||= Config::LoadPaths.new(root)
end

#middleware ⇒ `Object`

Application middleware.

Specify middleware that your application will use. This method will return the application’s underlying Middleware stack which you can use to add new middleware for your application to use. By default, the middleware stack will contain only Rack::Static and Rack::MethodOverride. However, if assets false was specified # in the configuration block, the default Rack::Static will be removed.

Examples:

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      middleware.use Rack::MethodOverride, nil, 'max-age=0, private, must-revalidate'
      middleware.use Rack::ETag
    end
  end
end

See Also:

Since:

0.2.0

Source: | on GitHub

def middleware
  @middleware ||= Hanami::MiddlewareStack.new(self)
end

#model ⇒ `Hanami::Config::FrameworkConfiguration`

It lazily collects all the low level settings for Hanami::Model’s configuration and applies them when the application is loaded.

NOTE: This forwards all the configurations to Hanami::Model, without checking them. Before to use this feature, please have a look at the current Hanami::Model version installed.

NOTE: This may override some configurations of your application.

Examples:

Define a setting

require 'hanami'
require 'hanami/model'

module Bookshelf
  class Application < Hanami::Application
    configure do
      model.adapter :sql, 'sqlite://db/bookshelf_development'
    end
  end
end

Override a setting

require 'hanami'
require 'hanami/model'

module Bookshelf
  class Application < Hanami::Application
    configure do
      adapter       :sql, 'postgresql://localhost/database'
      model.adapter :sql, 'sqlite://db/bookshelf_development'
    end
  end
end

# The sqlite adapter will override the SQL one

Returns:

(Hanami::Config::FrameworkConfiguration) —

the configuration

See Also:

Since:

0.2.0

Source: | on GitHub

def model
  @model ||= Config::FrameworkConfiguration.new
end

#port(value) ⇒ `Object` #scheme ⇒ `String`

The URI port for this application. This is used by the router helpers to generate absolute URLs.

By default this value is 2300.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.port # => 2300

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      port 8080
    end
  end
end

Bookshelf::Application.configuration.port # => 8080

Overloads:

#port(value) ⇒ Object

Sets the given value
Parameters:
- value (#to_int) —
  
  the URI port
Raises:
- (TypeError) —
  
  if the given value cannot be coerced to Integer
#scheme ⇒ String

Gets the value
Returns:
- (String)

See Also:

Since:

0.1.0

Source: | on GitHub

def port(value = nil)
  if value
    @port = Integer(value)
  else
    return @port if defined?(@port)
    return @env.port unless @env.default_port?
    return DEFAULT_SSL_PORT if force_ssl
    @env.port
  end
end

#root(value) ⇒ `Object` #root ⇒ `Pathname`

The root of the application

By default it returns the current directory, for this reason, all the commands must be executed from the top level directory of the project.

If for some reason, that constraint above cannot be satisfied, please configure the root directory, so that commands can be executed from everywhere.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.root # => #<Pathname:/path/to/root>

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      root '/path/to/another/root'
    end
  end
end

Overloads:

#root(value) ⇒ Object

Sets the given value
Parameters:
- value (String, Pathname, #to_pathname) —
  
  The root directory of the app
#root ⇒ Pathname

Gets the value
Returns:
- (Pathname)
Raises:
- (Errno::ENOENT) —
  
  if the path cannot be found

See Also:

Since:

0.1.0

Source: | on GitHub

def root(value = nil)
  if value
    @root = value
  else
    Utils::Kernel.Pathname(@root || Dir.pwd).realpath
  end
end

#routes(blk) ⇒ `Object` #routes(path) ⇒ `Object` #routes ⇒ `Hanami::Config::Routes`

Application routes.

Specify a set of routes for the application, by passing a block, or a relative path where to find the file that describes them.

By default it’s nil.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.routes
  # => nil

Setting the value, by passing a block

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      routes do
        get '/', to: 'dashboard#index'
        resources :books
      end
    end
  end
end

Bookshelf::Application.configuration.routes
  # => #<Hanami::Config::Routes:0x007ff50a991388 @blk=#<Proc:0x007ff50a991338@(irb):4>, @path=#<Pathname:.>>

Setting the value, by passing a relative path

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      routes 'config/routes'
    end
  end
end

Bookshelf::Application.configuration.routes
  # => #<Hanami::Config::Routes:0x007ff50a991388 @blk=nil, @path=#<Pathname:config/routes.rb>>

Overloads:

#routes(blk) ⇒ Object

Specify a set of routes in the given block
Parameters:
- blk (Proc) —
  
  the routes definitions
#routes(path) ⇒ Object

Specify a relative path where to find the routes file
Parameters:
- path (String) —
  
  the relative path
#routes ⇒ Hanami::Config::Routes

Gets the value
Returns:
- (Hanami::Config::Routes) —
  
  the set of routes

See Also:

Since:

0.1.0

Source: | on GitHub

def routes(path = nil, &blk)
  if path or block_given?
    @routes = Config::Routes.new(root, path, &blk)
  else
    @routes
  end
end

#scheme(value) ⇒ `Object` #scheme ⇒ `String`

The URI scheme for this application. This is used by the router helpers to generate absolute URLs.

By default this value is "http".

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.scheme # => "http"

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      scheme 'https'
    end
  end
end

Bookshelf::Application.configuration.scheme # => "https"

Overloads:

#scheme(value) ⇒ Object

Sets the given value
Parameters:
- value (String) —
  
  the URI scheme
#scheme ⇒ String

Gets the value
Returns:
- (String)

See Also:

Since:

0.1.0

Source: | on GitHub

def scheme(value = nil)
  if value
    @scheme = value
  else
    @scheme ||= 'http'
  end
end

#security ⇒ `Hanami::Config::Security`

Returns the security policy

Examples:

Getting values

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      security.x_frame_options         "ALLOW ALL"
      security.content_security_policy "script-src 'self' https://apis.example.com"
    end
  end
end

Bookshelf::Application.configuration.security.x_frame_options         # => "ALLOW ALL"
Bookshelf::Application.configuration.security.content_security_policy # => "script-src 'self' https://apis.example.com"

Setting values

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      security.x_frame_options         "ALLOW ALL"
      security.content_security_policy "script-src 'self' https://apis.example.com"
    end
  end
end

Returns:

(Hanami::Config::Security)

See Also:

Since:

0.3.0

Source: | on GitHub

def security
  @security ||= Config::Security.new
end

#sessions(adapter, options) ⇒ `Object` #sessions(false) ⇒ `Object` #sessions ⇒ `Hanami::Config::Sessions`

Configure sessions Enable sessions (disabled by default).

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Given Class as adapter it will be used as sessions middleware. Given String as adapter it will be resolved as class name and used as sessions middleware. Given Symbol as adapter it is assumed it’s name of the class under Rack::Session namespace that will be used as sessions middleware (e.g. :cookie for Rack::Session::Cookie).

By default options include domain inferred from host configuration, and secure flag inferred from scheme configuration.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.sessions
  # => #<Hanami::Config::Sessions:0x00000001ca0c28 @enabled=false>

Setting the value with symbol

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      sessions :cookie, secret: 'abc123'
    end
  end
end

Bookshelf::Application.configuration.sessions
  # => #<Hanami::Config::Sessions:0x00000001589458 @enabled=true, @adapter=:cookie, @options={:domain=>"localhost", :secure=>false}>

Disabling previously enabled sessions

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      sessions :cookie
      sessions false
    end
  end
end

Bookshelf::Application.configuration.sessions
  # => #<Hanami::Config::Sessions:0x00000002460d78 @enabled=false>

Overloads:

#sessions(adapter, options) ⇒ Object

Sets the given value.
Parameters:
- adapter (Class, String, Symbol) —
  
  Rack middleware for sessions management
- options (Hash) —
  
  options to pass to sessions middleware
#sessions(false) ⇒ Object

Disables sessions
#sessions ⇒ Hanami::Config::Sessions

Gets the value.
Returns:
- (Hanami::Config::Sessions) —
  
  sessions configuration

See Also:

Since:

0.2.0

Source: | on GitHub

def sessions(adapter = nil, options = {})
  if adapter.nil?
    @sessions ||= Config::Sessions.new
  else
    @sessions = Config::Sessions.new(adapter, options, self)
  end
end

#ssl? ⇒ `FalseClass`, `TrueClass`

Check if the application uses SSL

Returns:

(FalseClass, TrueClass) —

the result of the check

See Also:

Since:

0.2.0

Source: | on GitHub

def ssl?
  scheme == SSL_SCHEME
end

#templates(value) ⇒ `Object` #templates ⇒ `Pathname`

Templates root. The application will recursively look for templates under this path.

By default it’s equal to the application root.

Otherwise, you can specify a different relative path under root.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
  end
end

Bookshelf::Application.configuration.templates
  # => #<Pathname:/root/path>

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      templates 'app/templates'
    end
  end
end

Bookshelf::Application.configuration.templates
  # => #<Pathname:/root/path/app/templates>

Overloads:

#templates(value) ⇒ Object

Sets the given value
Parameters:
- value (String) —
  
  the relative path to the templates root.
#templates ⇒ Pathname

Gets the value
Returns:
- (Pathname) —
  
  templates root

See Also:

Since:

0.1.0

Source: | on GitHub

def templates(value = nil)
  if value
    @templates = value
  else
    root.join @templates.to_s
  end
end

#view ⇒ `Hanami::Config::FrameworkConfiguration`

It lazily collects all the low level settings for Hanami::View’s configuration and applies them when the application is loaded.

NOTE: This forwards all the configurations to Hanami::View, without checking them. Before to use this feature, please have a look at the current Hanami::View version installed.

NOTE: This may override some configurations of your application.

Examples:

Define a setting

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      view.layout :application
    end
  end
end

Override a setting

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      layout      :application
      view.layout :backend
    end
  end
end

# It will use `:backend` layout

Returns:

(Hanami::Config::FrameworkConfiguration) —

the configuration

See Also:

Since:

0.2.0

Source: | on GitHub

def view
  @view ||= Config::FrameworkConfiguration.new
end

#view_pattern(value) ⇒ `Object` #controller_pattern ⇒ `String`

Defines a relative pattern to find views:.

By default this equals to "Views::%{controller}::%{action}" That means views must be structured like this: Bookshelf::Views::Dashboard::Index, where Bookshelf is the application module, Views is the first value specified in the pattern, Dashboard a module corresponding to the controller name and Index the view, corresponding to the action name.

This pattern MUST always contain "%{controller}" and %{action}. This pattern SHOULD be used accordingly to #controller_pattern value.

This is part of a DSL, for this reason when this method is called with an argument, it will set the corresponding instance variable. When called without, it will return the already set value, or the default.

Examples:

Getting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      routes do
        get '/', to: 'dashboard#index'
      end
    end
  end

  module Views
    module Dashboard
      class Index
        include Bookshelf::View
      end
    end
  end
end

Bookshelf::Application.configuration.view_pattern
  # => "Views::%{controller}::%{action}"

# All the views MUST live under Bookshelf::Views

# GET '/' # => Bookshelf::Views::Dashboard::Index

Setting the value

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      view_pattern "%{controller}::%{action}"

      routes do
        get '/', to: 'dashboard#index'
      end
    end
  end

  module Dashboard
    class Index
      include Bookshelf::View
    end
  end
end

Bookshelf::Application.configuration.view_pattern
  # => "%{controller}::%{action}"

# All the views are directly under the Bookshelf module

# GET '/' # => Bookshelf::Dashboard::Index

Setting the value for a top level name structure

require 'hanami'

module Bookshelf
  class Application < Hanami::Application
    configure do
      view_pattern "%{controller}::%{action}"

      routes do
        get '/', to: 'dashboard#index'
      end
    end
  end
end

module Dashboard
  class Index
    include Bookshelf::View
  end
end

Bookshelf::Application.configuration.view_pattern
  # => "%{controller}::%{action}"

# All the views: are at the top level namespace

# GET '/' # => Dashboard::Index

Overloads:

#view_pattern(value) ⇒ Object

Sets the given value
Parameters:
- value (String) —
  
  the view pattern
#controller_pattern ⇒ String

Gets the value
Returns:
- (String)

See Also:

Since:

0.1.0

Source: | on GitHub

def view_pattern(value = nil)
  if value
    @view_pattern = value
  else
    @view_pattern ||= 'Views::%{controller}::%{action}'
  end
end

Overview

Instance Method Summary collapse

Instance Method Details

#adapter(options) ⇒ `Object` #adapter ⇒ `Hash`

#assets ⇒ `Hanami::Config::Assets`

#body_parsers(parsers) ⇒ `Object` #body_parsers ⇒ `Array`

#controller ⇒ `Hanami::Config::FrameworkConfiguration`

#controller_pattern(value) ⇒ `Object` #controller_pattern ⇒ `String`

#cookies(options) ⇒ `Object` #cookies ⇒ `Hanami::Config::Cookies`

#default_request_format(format) ⇒ `Object` #default_request_format ⇒ `Symbol`

#default_response_format(format) ⇒ `Object` #default_response_format ⇒ `Symbol`^?

#force_ssl(value = nil) ⇒ `Boolean`

#handle_exceptions(value) ⇒ `Object` #handle_exceptions ⇒ `TrueClass`, `FalseClass`

#host(value) ⇒ `Object` #scheme ⇒ `String`

#layout(value) ⇒ `Object` #layout ⇒ `Symbol`^?

#load_paths ⇒ `Hanami::Config::LoadPaths`

#middleware ⇒ `Object`

#model ⇒ `Hanami::Config::FrameworkConfiguration`

#port(value) ⇒ `Object` #scheme ⇒ `String`

#root(value) ⇒ `Object` #root ⇒ `Pathname`

#routes(blk) ⇒ `Object` #routes(path) ⇒ `Object` #routes ⇒ `Hanami::Config::Routes`

#scheme(value) ⇒ `Object` #scheme ⇒ `String`

#security ⇒ `Hanami::Config::Security`

#sessions(adapter, options) ⇒ `Object` #sessions(false) ⇒ `Object` #sessions ⇒ `Hanami::Config::Sessions`

#ssl? ⇒ `FalseClass`, `TrueClass`

#templates(value) ⇒ `Object` #templates ⇒ `Pathname`

#view ⇒ `Hanami::Config::FrameworkConfiguration`

#view_pattern(value) ⇒ `Object` #controller_pattern ⇒ `String`

Class: Hanami::ApplicationConfiguration

Overview

Instance Method Summary collapse

Instance Method Details

#adapter(options) ⇒ Object #adapter ⇒ Hash

#assets ⇒ Hanami::Config::Assets

#body_parsers(parsers) ⇒ Object #body_parsers ⇒ Array

#controller ⇒ Hanami::Config::FrameworkConfiguration

#controller_pattern(value) ⇒ Object #controller_pattern ⇒ String

#cookies(options) ⇒ Object #cookies ⇒ Hanami::Config::Cookies

#default_request_format(format) ⇒ Object #default_request_format ⇒ Symbol

#default_response_format(format) ⇒ Object #default_response_format ⇒ Symbol?

#force_ssl(value = nil) ⇒ Boolean

#handle_exceptions(value) ⇒ Object #handle_exceptions ⇒ TrueClass, FalseClass

#host(value) ⇒ Object #scheme ⇒ String

#layout(value) ⇒ Object #layout ⇒ Symbol?

#load_paths ⇒ Hanami::Config::LoadPaths

#middleware ⇒ Object

#model ⇒ Hanami::Config::FrameworkConfiguration

#port(value) ⇒ Object #scheme ⇒ String

#root(value) ⇒ Object #root ⇒ Pathname

#routes(blk) ⇒ Object #routes(path) ⇒ Object #routes ⇒ Hanami::Config::Routes

#scheme(value) ⇒ Object #scheme ⇒ String

#security ⇒ Hanami::Config::Security

#sessions(adapter, options) ⇒ Object #sessions(false) ⇒ Object #sessions ⇒ Hanami::Config::Sessions

#ssl? ⇒ FalseClass, TrueClass

#templates(value) ⇒ Object #templates ⇒ Pathname

#view ⇒ Hanami::Config::FrameworkConfiguration

#view_pattern(value) ⇒ Object #controller_pattern ⇒ String

#adapter(options) ⇒ `Object` #adapter ⇒ `Hash`

#assets ⇒ `Hanami::Config::Assets`

#body_parsers(parsers) ⇒ `Object` #body_parsers ⇒ `Array`

#controller ⇒ `Hanami::Config::FrameworkConfiguration`

#controller_pattern(value) ⇒ `Object` #controller_pattern ⇒ `String`

#cookies(options) ⇒ `Object` #cookies ⇒ `Hanami::Config::Cookies`

#default_request_format(format) ⇒ `Object` #default_request_format ⇒ `Symbol`

#default_response_format(format) ⇒ `Object` #default_response_format ⇒ `Symbol`^?

#force_ssl(value = nil) ⇒ `Boolean`

#handle_exceptions(value) ⇒ `Object` #handle_exceptions ⇒ `TrueClass`, `FalseClass`

#host(value) ⇒ `Object` #scheme ⇒ `String`

#layout(value) ⇒ `Object` #layout ⇒ `Symbol`^?

#load_paths ⇒ `Hanami::Config::LoadPaths`

#middleware ⇒ `Object`

#model ⇒ `Hanami::Config::FrameworkConfiguration`

#port(value) ⇒ `Object` #scheme ⇒ `String`

#root(value) ⇒ `Object` #root ⇒ `Pathname`

#routes(blk) ⇒ `Object` #routes(path) ⇒ `Object` #routes ⇒ `Hanami::Config::Routes`

#scheme(value) ⇒ `Object` #scheme ⇒ `String`

#security ⇒ `Hanami::Config::Security`

#sessions(adapter, options) ⇒ `Object` #sessions(false) ⇒ `Object` #sessions ⇒ `Hanami::Config::Sessions`

#ssl? ⇒ `FalseClass`, `TrueClass`

#templates(value) ⇒ `Object` #templates ⇒ `Pathname`

#view ⇒ `Hanami::Config::FrameworkConfiguration`

#view_pattern(value) ⇒ `Object` #controller_pattern ⇒ `String`