Class: Hanami::Config

Inherits:
Object
  • Object
show all
Includes:
Dry::Configurable
Defined in:
lib/hanami/config.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, 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



281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
 
# File 'lib/hanami/config.rb', line 281

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

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

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

  @router = load_dependent_config("hanami-router") {
    require_relative "config/router"
    @middleware = Slice::Routing::Middleware::Stack.new
    Router.new(self)
  }

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

  @assets = load_dependent_config("hanami-assets") {
    require_relative "config/assets"
    Hanami::Config::Assets.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



476
477
478
479
480
481
482
 
# File 'lib/hanami/config.rb', line 476

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



217
218
219
 
# File 'lib/hanami/config.rb', line 217

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



190
191
192
 
# File 'lib/hanami/config.rb', line 190

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



277
278
279
 
# File 'lib/hanami/config.rb', line 277

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



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

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

#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



203
204
205
 
# File 'lib/hanami/config.rb', line 203

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



231
232
233
 
# File 'lib/hanami/config.rb', line 231

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
 
# File 'lib/hanami/config.rb', line 113

setting :no_auto_register_paths, default: %w[entities]

#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



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

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



177
178
179
180
 
# File 'lib/hanami/config.rb', line 177

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



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

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



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

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



263
264
265
 
# File 'lib/hanami/config.rb', line 263

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



340
341
342
343
344
345
346
347
348
349
350
351
 
# File 'lib/hanami/config.rb', line 340

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



369
370
371
 
# File 'lib/hanami/config.rb', line 369

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



390
391
392
 
# File 'lib/hanami/config.rb', line 390

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



402
403
404
 
# File 'lib/hanami/config.rb', line 402

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



437
438
439
 
# File 'lib/hanami/config.rb', line 437

def logger_instance
  @logger_instance || logger.instance
end