Class: Hanami::Config

Inherits:
Object
  • Object
show all
Includes:
Dry::Configurable
Defined in:
lib/hanami/config.rb,
lib/hanami/config/db.rb,
lib/hanami/config/views.rb,
lib/hanami/config/assets.rb,
lib/hanami/config/logger.rb,
lib/hanami/config/router.rb,
lib/hanami/config/actions.rb,
lib/hanami/config/null_config.rb,
lib/hanami/config/actions/cookies.rb,
lib/hanami/config/actions/sessions.rb,
lib/hanami/config/actions/content_security_policy.rb

Overview

Hanami app config

Since:

  • 2.0.0

Defined Under Namespace

Classes: Actions, Assets, DB, Logger, NullConfig, Router, Views

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(app_name:, env:) {|_self| ... } ⇒ Config

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

rubocop:disable Metrics/AbcSize

Yields:

  • (_self)

Yield Parameters:

Since:

  • 2.0.0



300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/hanami/config.rb', line 300

def initialize(app_name:, env:)
  @app_name = app_name
  @env = env

  # Apply default values that are only knowable at initialize-time (vs require-time)
  self.root = Dir.pwd
  self.render_errors = (env == :production)
  self.render_detailed_errors = (env == :development)
  load_from_env


  @actions = load_dependent_config("hanami-controller") {
    require_relative "config/actions"
    Actions.new
  }

  @assets = load_dependent_config("hanami-assets") {
    require_relative "config/assets"
    Hanami::Config::Assets.new
  }

  @db = load_dependent_config("hanami-db") { DB.new }

  @logger = Config::Logger.new(env: env, app_name: app_name)

  @middleware = load_dependent_config("hanami-router") {
    Slice::Routing::Middleware::Stack.new
  }

  @router = load_dependent_config("hanami-router") {
    require_relative "config/router"
    Router.new(self)
  }

  @views = load_dependent_config("hanami-view") {
    require_relative "config/views"
    Views.new
  }

  yield self if block_given?
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(name, *args, &block) ⇒ Object (private)

Since:

  • 2.0.0



503
504
505
506
507
508
509
 
# File 'lib/hanami/config.rb', line 503

def method_missing(name, *args, &block)
  if config.respond_to?(name)
    config.public_send(name, *args, &block)
  else
    super
  end
end

Instance Attribute Details

#actions ⇒ Hanami::Config::Actions, Hanami::Config::NullConfig (readonly)

Returns the app’s actions config, or a null config if hanami-controller is not bundled.

Examples:

When hanami-controller is bundled

config.actions.default_request_format # => :html

When hanami-controller is not bundled

config.actions.default_request_format # => NoMethodError

Returns:

Since:

  • 2.0.0



222
223
224
 
# File 'lib/hanami/config.rb', line 222

def actions
  @actions
end

#app_name ⇒ Hanami::SliceName (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the app or slice’s slice_name.

This is useful for default config values that depend on this name.

Returns:

Since:

  • 2.0.0



195
196
197
 
# File 'lib/hanami/config.rb', line 195

def app_name
  @app_name
end

#assets ⇒ Hanami::Config::Assets, Hanami::Config::NullConfig (readonly)

Returns the app’s views config, or a null config if hanami-view is not bundled.

Examples:

When hanami-view is bundled

config.views.paths # => [...]

When hanami-view is not bundled

config.views.paths # => NoMethodError

Returns:

Since:

  • 2.1.0



296
297
298
 
# File 'lib/hanami/config.rb', line 296

def assets
  @assets
end

#base_url ⇒ URI

Sets the base URL for app’s web server.

This is passed to the router and used for generating links.

Defaults to ‘“0.0.0.0:2300”`. String values passed are turned into `URI` instances.

Returns:

  • (URI)

See Also:

Since:

  • 2.0.0



133
 
# File 'lib/hanami/config.rb', line 133

setting :base_url, default: "http://0.0.0.0:2300", constructor: ->(url) { URI(url) }

#db ⇒ Hanami::Config::DB, Hanami::Config::NullConfig (readonly)

Returns the app’s db config, or a null config if hanami-db is not bundled.

Examples:

When hanami-db is bundled

config.db.import_from_parent # => false

When hanami-db is not bundle

config.db.import_from_parent # => NoMethodError

Returns:

Since:

  • 2.2.0



236
237
238
 
# File 'lib/hanami/config.rb', line 236

def db
  @db
end

#env ⇒ Symbol (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the app’s environment.

Examples:

config.env # => :development

Returns:

  • (Symbol)

See Also:

  • #environment

Since:

  • 2.0.0



208
209
210
 
# File 'lib/hanami/config.rb', line 208

def env
  @env
end

#inflector ⇒ Dry::Inflector

Sets the app’s inflector.

This expects a ‘Dry::Inflector` (or compatible) inflector instance.

To configure custom inflection rules without having to assign a whole inflector, see #inflections.

Returns:

  • (Dry::Inflector)

See Also:

Since:

  • 2.0.0



45
 
# File 'lib/hanami/config.rb', line 45

setting :inflector, default: Dry::Inflector.new

#middleware ⇒ Hanami::Slice::Routing::Middleware::Stack? (readonly) Also known as: middleware_stack

Returns the app’s middleware stack, or nil if hanami-router is not bundled.

Use this to configure middleware that should apply to all routes.

Examples:

config.middleware.use :body_parser, :json
config.middleware.use MyCustomMiddleware

Returns:

Since:

  • 2.0.0



250
251
252
 
# File 'lib/hanami/config.rb', line 250

def middleware
  @middleware
end

#no_auto_register_paths ⇒ Array<String>

Sets the paths to skip from container auto-registration.

Defaults to ‘[“entities”]`.

Returns:

  • (Array<String>) —

    array of relative paths

Since:

  • 2.0.0



113
114
115
116
117
118
 
# File 'lib/hanami/config.rb', line 113

setting :no_auto_register_paths, default: [
  "db",
  "entities",
  "relations",
  "structs"
]

#render_detailed_errors ⇒ Boolean

Sets whether to catch exceptions and render detailed, interactive error pages.

Requires the hanami-webconsole gem to be available.

Defaults to ‘false` in production mode, `true` in all others.

Returns:

  • (Boolean)

Since:

  • 2.1.0



159
 
# File 'lib/hanami/config.rb', line 159

setting :render_detailed_errors, default: false

#render_error_responses ⇒ Hash{String => Symbol}

Sets a mapping of exception class names (as strings) to symbolic response status codes used for rendering error responses.

The response status codes will be passed to ‘Rack::Utils.status_code`.

In ordinary usage, you should not replace this hash. Instead, add keys and values for the errors you want handled.

Examples:

config.render_error_responses
# => {"Hanami::Router::NotFoundError" => :not_found}

config.render_error_responses["MyNotFoundError"] = :not_found

Returns:

  • (Hash{String => Symbol})

See Also:

Since:

  • 2.1.0



182
183
184
185
 
# File 'lib/hanami/config.rb', line 182

setting :render_error_responses, default: Hash.new(:internal_server_error).merge!(
  "Hanami::Router::NotAllowedError" => :not_found,
  "Hanami::Router::NotFoundError" => :not_found,
)

#render_errors ⇒ Boolean

Sets whether to catch exceptions and render error pages.

For HTML responses, these error pages are in ‘public/404,500.html`.

Defaults to ‘true` in production mode, `false` in all others.

Returns:

  • (Boolean)

Since:

  • 2.1.0



146
 
# File 'lib/hanami/config.rb', line 146

setting :render_errors, default: false

#root ⇒ Pathname

Sets the root for the app or slice.

For the app, this defaults to ‘Dir.pwd`. For slices detected in `slices/` `config/slices/`, this defaults to `slices//`.

Accepts a string path and will return a ‘Pathname`.

Returns:

  • (Pathname)

Since:

  • 2.0.0



29
 
# File 'lib/hanami/config.rb', line 29

setting :root, constructor: ->(path) { Pathname(path) if path }

#router ⇒ Hanami::Config::Router, Hanami::Config::NullConfig (readonly)

Returns the app’s router config, or a null config if hanami-router is not bundled.

Examples:

When hanami-router is bundled

config.router.resolver # => Hanami::Slice::Routing::Resolver

When hanami-router is not bundled

config.router.resolver # => NoMethodError

Returns:

Since:

  • 2.0.0



268
269
270
 
# File 'lib/hanami/config.rb', line 268

def router
  @router
end

#settings_store ⇒ #fetch

Sets the store used to retrieve Settings values.

Defaults to an instance of Settings::EnvStore.

Returns:

  • (#fetch)

See Also:

Since:

  • 2.0.0



59
 
# File 'lib/hanami/config.rb', line 59

setting :settings_store, default: Hanami::Settings::EnvStore.new

#shared_app_component_keys ⇒ Array<String>

Sets the keys for the components to be imported from the app into all other slices.

You should append items to this array, since the default shared components are essential for slices to operate within the app.

Examples:

config.shared_app_component_keys += ["shared_component_a", "shared_component_b"]

Returns:

  • (Array<String>)

Since:

  • 2.0.0



95
96
97
98
99
100
101
102
 
# File 'lib/hanami/config.rb', line 95

setting :shared_app_component_keys, default: %w[
  inflector
  logger
  notifications
  rack.monitor
  routes
  settings
]

#slices ⇒ Array<String>?

Sets the slices to load when the app is preared or booted.

Defaults to ‘nil`, which will load all slices. Set this to an array of slice names to load only those slices.

This attribute is also populated from the ‘HANAMI_SLICES` environment variable.

Examples:

config.slices = ["admin", "search"]
ENV["HANAMI_SLICES"] # => "admin,search"
config.slices # => ["admin", "search"]

Returns:

  • (Array<String>, nil)

Since:

  • 2.0.0



80
 
# File 'lib/hanami/config.rb', line 80

setting :slices

#views ⇒ Hanami::Config::Views, Hanami::Config::NullConfig (readonly)

Returns the app’s views config, or a null config if hanami-view is not bundled.

Examples:

When hanami-view is bundled

config.views.paths # => [...]

When hanami-view is not bundled

config.views.paths # => NoMethodError

Returns:

Since:

  • 2.1.0



282
283
284
 
# File 'lib/hanami/config.rb', line 282

def views
  @views
end

Instance Method Details

#finalize! ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Finalizes the config.

This is called when the app or slice is prepared. After this, no further changes to config can be made.

Since:

  • 2.0.0



367
368
369
370
371
372
373
374
375
376
377
378
 
# File 'lib/hanami/config.rb', line 367

def finalize!
  # Finalize nested configs
  assets.finalize!
  actions.finalize!(self)
  views.finalize!
  logger.finalize!
  router.finalize!

  use_body_parser_middleware

  super
end

#inflections(&block) ⇒ Dry::Inflector

Configures the app’s custom inflections.

You should call this one time only. Subsequent calls will override previously configured inflections.

Examples:

config.inflections do |inflections|
  inflections.acronym "WNBA"
end

Returns:

  • (Dry::Inflector) —

    the configured inflector

See Also:

Since:

  • 2.0.0



396
397
398
 
# File 'lib/hanami/config.rb', line 396

def inflections(&block)
  self.inflector = Dry::Inflector.new(&block)
end

#logger ⇒ Hanami::Config::Logger

Returns the logger config.

Use this to configure various options for the default ‘Dry::Logger::Dispatcher` logger instance.

Examples:

config.logger.level = :debug

Returns:

See Also:

Since:

  • 2.0.0



417
418
419
 
# File 'lib/hanami/config.rb', line 417

def logger
  @logger
end

#logger=(logger_instance) ⇒ Object

Sets the app’s logger instance.

This entirely replaces the default ‘Dry::Logger::Dispatcher` instance that would have been

See Also:

Since:

  • 2.0.0



429
430
431
 
# File 'lib/hanami/config.rb', line 429

def logger=(logger_instance)
  @logger_instance = logger_instance
end

#logger_instance ⇒ Dry::Logger::Dispatcher

Returns the configured logger instance.

Unless you’ve replaced the logger with #logger=, this returns a ‘Dry::Logger::Dispatcher` configured with the options configured through #logger.

This configured logger is registered in all app and slice containers as ‘“logger”`. For typical usage, you should access the logger via this component, not directly from config.

Examples:

Accessing the logger component

Hanami.app["logger"] # => #<Dry::Logger::Dispatcher>

Injecting the logger as a dependency

module MyApp
  class MyClass
    include Deps["logger"]

    def my_method
      logger.info("hello")
    end
  end
end

Returns:

  • (Dry::Logger::Dispatcher)

See Also:

Since:

  • 2.0.0



464
465
466
 
# File 'lib/hanami/config.rb', line 464

def logger_instance
  @logger_instance || logger.instance
end