Module: Hanami::Slice::ClassMethods
- Defined in:
- lib/hanami/slice.rb
Overview
rubocop:disable Metrics/ModuleLength
Instance Attribute Summary collapse
-
#autoloader ⇒ Zeitwerk::Loader
readonly
Returns the slice’s autoloader.
-
#container ⇒ Object
readonly
Returns the slice’s container.
-
#parent ⇒ Hanami::Slice
readonly
Returns the slice’s parent.
Instance Method Summary collapse
-
#[](key) ⇒ Object
Resolves the component with the given key from the container.
-
#app ⇒ Hanami::App
Returns the Hanami app.
-
#boot ⇒ self
Boots the slice.
-
#booted? ⇒ Boolean
Returns true if the slice has been booted.
-
#call(rack_env) ⇒ Array
Calls the slice’s [Rack] app and returns a Rack-compatible response object.
-
#config ⇒ Hanami::Config
Returns the slice’s config.
-
#environment(env_name, &block) ⇒ self
Evaluates the block for a given app environment only.
-
#export(keys) ⇒ self
Specifies the components to export from the slice.
-
#import(from: , as: nil, keys: nil) ⇒ Object
Specifies components to import from another slice.
-
#inflector ⇒ Dry::Inflector
Returns the slice’s configured inflector.
-
#key?(key) ⇒ Boolean
Returns true if the component with the given key is registered in the container.
-
#keys ⇒ Array<String>
Returns an array of keys for all currently registered components in the container.
-
#namespace ⇒ Module
Returns the constant for the slice’s module namespace.
- #prepare(provider_name = nil) ⇒ Object
-
#prepare_container {|container| ... } ⇒ self
Captures the given block to be called with the slice’s container during the slice’s ‘prepare` step, after the slice has already configured the container.
-
#prepared? ⇒ Boolean
Returns true if the slice has been prepared.
-
#rack_app ⇒ #call?
Returns a [Rack] app for the slice, or nil if no routes are defined.
-
#register ⇒ container
Registers a component in the slice’s container.
-
#register_provider(name, namespace: nil, from: nil, source: nil) ⇒ container
Registers a provider and its lifecycle hooks.
- #register_slice ⇒ slices
- #resolve ⇒ Object
-
#root ⇒ Pathname
Returns the slice’s root, either the root as explicitly configured, or a default fallback of the slice’s name within the app’s ‘slices/` dir.
-
#router(inspector: nil) ⇒ Hanami::Slice::Router?
Returns the slice’s router, if or nil if no routes are defined.
-
#routes ⇒ Hanami::Routes?
Returns the slice’s routes, or nil if no routes are defined.
-
#settings ⇒ Hanami::Settings?
Returns the slice’s settings, or nil if no settings are defined.
-
#shutdown ⇒ self
Shuts down the slice’s providers, as well as the providers in any nested slices.
-
#slice_name ⇒ SliceName
Returns a Hanami::SliceName for the slice, an object with methods returning the name of the slice in various formats.
-
#slices ⇒ SliceRegistrar
Returns the slice’s collection of nested slices.
-
#start(provider_name) ⇒ container
Starts a provider.
-
#stop(provider_name) ⇒ container
Stops a provider.
Instance Attribute Details
#autoloader ⇒ Zeitwerk::Loader (readonly)
Returns the slice’s autoloader.
Each slice has its own ‘Zeitwerk::Loader` autoloader instance, which is setup when the slice is prepared.
76 77 78 |
# File 'lib/hanami/slice.rb', line 76 def autoloader @autoloader end |
#container ⇒ Object (readonly)
Returns the slice’s container.
This is a ‘Dry::System::Container` that is already configured for the slice.
In ordinary usage, you shouldn’t need direct access the container at all, since the slice provides its own methods for interacting with the container (such as #[], #keys, #key? #register, #register_provider, #prepare, #start, #stop).
If you need to configure the container directly, use #prepare_container.
92 93 94 |
# File 'lib/hanami/slice.rb', line 92 def container @container end |
#parent ⇒ Hanami::Slice (readonly)
Returns the slice’s parent.
For top-level slices defined in ‘slices/` or `config/slices/`, this will be the Hanami app itself (`Hanami.app`). For nested slices, this will be the slice in which they were registered.
63 64 65 |
# File 'lib/hanami/slice.rb', line 63 def parent @parent end |
Instance Method Details
#[](key) ⇒ Object
590 591 592 |
# File 'lib/hanami/slice.rb', line 590 def [](...) container.[](...) end |
#app ⇒ Hanami::App
Returns the Hanami app.
100 101 102 |
# File 'lib/hanami/slice.rb', line 100 def app Hanami.app end |
#boot ⇒ self
Boots the slice.
This will prepare the slice (if not already prepared), start each of its providers, register all the slice’s components from its Ruby source files, and import components from any other slices. It will also boot any of the slice’s own registered nested slices. It will then freeze its container so no further components can be registered.
Call ‘boot` if you want to fully load a slice and incur all load time up front, such as when preparing an app to serve web requests. Booting slices is the approach taken when running Hanami’s standard Puma setup (see ‘config.ru`).
305 306 307 308 309 310 311 312 313 314 315 316 |
# File 'lib/hanami/slice.rb', line 305 def boot return self if booted? prepare container.finalize! slices.each(&:boot) @booted = true self end |
#booted? ⇒ Boolean
Returns true if the slice has been booted.
350 351 352 |
# File 'lib/hanami/slice.rb', line 350 def booted? !!@booted end |
#call(rack_env) ⇒ Array
757 758 759 |
# File 'lib/hanami/slice.rb', line 757 def call(...) rack_app.call(...) end |
#config ⇒ Hanami::Config
Returns the slice’s config.
A slice’s config is copied from the app config at time of first access.
114 115 116 117 118 119 |
# File 'lib/hanami/slice.rb', line 114 def config @config ||= app.config.dup.tap do |slice_config| # Unset config from app that does not apply to ordinary slices slice_config.root = nil end end |
#environment(env_name) ⇒ self #environment(env_name) {|slice| ... } ⇒ self
Evaluates the block for a given app environment only.
If the given ‘env_name` matches Hanami.env, then the block will be evaluated in the context of `self` (the slice) via `instance_eval`. The slice is also passed as the block’s optional argument.
If the env does not match, then the block is not evaluated at all.
151 152 153 154 |
# File 'lib/hanami/slice.rb', line 151 def environment(env_name, &block) instance_eval(&block) if env_name == config.env self end |
#export(keys) ⇒ self
Specifies the components to export from the slice.
Slices importing from this slice can import the specified components only.
619 620 621 622 |
# File 'lib/hanami/slice.rb', line 619 def export(keys) container.config.exports = keys self end |
#import(from: , as: nil, keys: nil) ⇒ Object
657 658 659 660 661 662 663 664 665 666 667 668 669 670 |
# File 'lib/hanami/slice.rb', line 657 def import(from:, **kwargs) slice = self container.after(:configure) do if from.is_a?(Symbol) || from.is_a?(String) slice_name = from from = slice.parent.slices[from.to_sym].container end as = kwargs[:as] || slice_name import(from: from, as: as, **kwargs) end end |
#inflector ⇒ Dry::Inflector
Returns the slice’s configured inflector.
Unless explicitly re-configured for the slice, this will be the app’s inflector.
217 218 219 |
# File 'lib/hanami/slice.rb', line 217 def inflector config.inflector end |
#key?(key) ⇒ Boolean
558 559 560 |
# File 'lib/hanami/slice.rb', line 558 def key?(...) container.key?(...) end |
#keys ⇒ Array<String>
Returns an array of keys for all currently registered components in the container.
For a prepared slice, this will be the set of components that have been previously resolved. For a booted slice, this will be all components available for the slice.
571 572 573 |
# File 'lib/hanami/slice.rb', line 571 def keys container.keys end |
#namespace ⇒ Module
Returns the constant for the slice’s module namespace.
178 179 180 |
# File 'lib/hanami/slice.rb', line 178 def namespace slice_name.namespace end |
#prepare ⇒ self #prepare(provider_name) ⇒ self
250 251 252 253 254 255 256 257 258 |
# File 'lib/hanami/slice.rb', line 250 def prepare(provider_name = nil) if provider_name container.prepare(provider_name) else prepare_slice end self end |
#prepare_container {|container| ... } ⇒ self
Captures the given block to be called with the slice’s container during the slice’s ‘prepare` step, after the slice has already configured the container.
This is intended for advanced usage only and should not be needed for ordinary slice configuration and usage.
283 284 285 286 |
# File 'lib/hanami/slice.rb', line 283 def prepare_container(&block) @prepare_container_block = block self end |
#prepared? ⇒ Boolean
Returns true if the slice has been prepared.
338 339 340 |
# File 'lib/hanami/slice.rb', line 338 def prepared? !!@prepared end |
#rack_app ⇒ #call?
Returns a [Rack] app for the slice, or nil if no routes are defined.
The rack app will be memoized on first access.
[rack]: github.com/rack/rack
738 739 740 741 742 |
# File 'lib/hanami/slice.rb', line 738 def rack_app return unless router @rack_app ||= router.to_rack_app end |
#register(key, object) ⇒ container #register(key, memoize: false, &block) ⇒ container #register(key, call: true, &block) ⇒ container
Registers a component in the slice’s container.
442 443 444 |
# File 'lib/hanami/slice.rb', line 442 def register(...) container.register(...) end |
#register_provider(name, namespace: nil, from: nil, source: nil) ⇒ container
506 507 508 |
# File 'lib/hanami/slice.rb', line 506 def register_provider(...) container.register_provider(...) end |
#register_slice(name) {|slice| ... } ⇒ slices #register_slice(name, slice_class) ⇒ slices
394 395 396 |
# File 'lib/hanami/slice.rb', line 394 def register_slice(...) slices.register(...) end |
#resolve ⇒ Object
598 599 600 |
# File 'lib/hanami/slice.rb', line 598 def resolve(...) container.resolve(...) end |
#root ⇒ Pathname
Returns the slice’s root, either the root as explicitly configured, or a default fallback of the slice’s name within the app’s ‘slices/` dir.
191 192 193 194 195 196 197 198 199 200 201 202 203 204 |
# File 'lib/hanami/slice.rb', line 191 def root # Provides a best guess for a root when it is not yet configured. # # This is particularly useful for user-defined slice classes that access `settings` inside # the class body (since the root needed to find the settings file). In this case, # `configuration.root` may be nil when `settings` is called, since the root is configured by # `SliceRegistrar#configure_slice` _after_ the class is loaded. # # In common cases, this best guess will be correct since most Hanami slices will be expected # to live in the app SLICES_DIR. For advanced cases, the correct slice root should be # explicitly configured at the beginning of the slice class body, before any calls to # `settings`. config.root || app.root.join(SLICES_DIR, slice_name.to_s) end |
#router(inspector: nil) ⇒ Hanami::Slice::Router?
Returns the slice’s router, if or nil if no routes are defined.
An optional ‘inspector`, implementing the `Hanami::Router::Inspector` interface, may be provided at first call (the router is then memoized for subsequent accesses). An inspector is used by the `hanami routes` CLI comment to provide a list of available routes.
The returned router is a Router, which provides all ‘Hanami::Router` functionality, with the addition of support for slice mounting with the Router#slice.
717 718 719 720 721 722 723 |
# File 'lib/hanami/slice.rb', line 717 def router(inspector: nil) raise SliceLoadError, "#{self} must be prepared before loading the router" unless prepared? @_mutex.synchronize do @_router ||= load_router(inspector: inspector) end end |
#routes ⇒ Hanami::Routes?
Returns the slice’s routes, or nil if no routes are defined.
You can define your routes in ‘config/routes.rb`.
698 699 700 |
# File 'lib/hanami/slice.rb', line 698 def routes @routes ||= load_routes end |
#settings ⇒ Hanami::Settings?
Returns the slice’s settings, or nil if no settings are defined.
You can define your settings in ‘config/settings.rb`.
682 683 684 685 686 |
# File 'lib/hanami/slice.rb', line 682 def settings return @settings if instance_variable_defined?(:@settings) @settings = Settings.load_for_slice(self) end |
#shutdown ⇒ self
Shuts down the slice’s providers, as well as the providers in any nested slices.
324 325 326 327 328 |
# File 'lib/hanami/slice.rb', line 324 def shutdown slices.each(&:shutdown) container.shutdown! self end |
#slice_name ⇒ SliceName
Returns a Hanami::SliceName for the slice, an object with methods returning the name of the slice in various formats.
163 164 165 |
# File 'lib/hanami/slice.rb', line 163 def slice_name @slice_name ||= SliceName.new(self, inflector: method(:inflector)) end |
#slices ⇒ SliceRegistrar
Returns the slice’s collection of nested slices.
362 363 364 |
# File 'lib/hanami/slice.rb', line 362 def slices @slices ||= SliceRegistrar.new(self) end |
#start(provider_name) ⇒ container
524 525 526 |
# File 'lib/hanami/slice.rb', line 524 def start(...) container.start(...) end |
#stop(provider_name) ⇒ container
542 543 544 |
# File 'lib/hanami/slice.rb', line 542 def stop(...) container.stop(...) end |