Module: Hanami::Slice::ClassMethods

def assets_dir?
  assets_path = app.eql?(self) ? root.join("app", "assets") : root.join("assets")
  assets_path.directory?
end

def call(...)
  rack_app.call(...)
end

def ensure_root
  unless config.root
    raise SliceLoadError, "Slice must have a `config.root` before it can be prepared"
  end
end

def ensure_slice_consts
  if namespace.const_defined?(:Container) || namespace.const_defined?(:Deps)
    raise(
      SliceLoadError,
      "#{namespace}::Container and #{namespace}::Deps constants must not already be defined"
    )
  end
end

def ensure_slice_name
  unless name
    raise SliceLoadError, "Slice must have a class name before it can be prepared"
  end
end

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

def key?(...)
  container.key?(...)
end

def load_router(inspector:)
  return unless routes

  require_relative "slice/router"

  slice = self
  config = self.config
  rack_monitor = self["rack.monitor"]

  show_welcome = Hanami.env?(:development) && routes.empty?
  render_errors = render_errors?
  render_detailed_errors = render_detailed_errors?

  error_handlers = {}.tap do |hsh|
    if render_errors || render_detailed_errors
      hsh[:not_allowed] = ROUTER_NOT_ALLOWED_HANDLER
      hsh[:not_found] = ROUTER_NOT_FOUND_HANDLER
    end
  end

  Slice::Router.new(
    inspector: inspector,
    routes: routes,
    resolver: config.router.resolver.new(slice: self),
    **error_handlers,
    **config.router.options
  ) do
    use(rack_monitor)

    use(Hanami::Web::Welcome) if show_welcome

    use(
      Hanami::Middleware::RenderErrors,
      config,
      Hanami::Middleware::PublicErrorsApp.new(slice.root.join("public"))
    )

    if render_detailed_errors
      require "hanami/webconsole"
      use(Hanami::Webconsole::Middleware, config)
    end

    if Hanami.bundled?("hanami-controller")
      if config.actions.method_override
        require "rack/method_override"
        use(Rack::MethodOverride)
      end

      if config.actions.sessions.enabled?
        use(*config.actions.sessions.middleware)
      end
    end

    if Hanami.bundled?("hanami-assets") && config.assets.serve
      use(Hanami::Middleware::Assets)
    end

    middleware_stack.update(config.middleware_stack)
  end
end

def load_routes
  return false unless Hanami.bundled?("hanami-router")

  if root.directory?
    routes_require_path = File.join(root, ROUTES_PATH)

    begin
      require_relative "./routes"
      require routes_require_path
    rescue LoadError => e
      raise e unless e.path == routes_require_path
    end
  end

  begin
    routes_class = namespace.const_get(ROUTES_CLASS_NAME)
    routes_class.routes
  rescue NameError => e
    raise e unless e.name == ROUTES_CLASS_NAME.to_sym
  end
end

def prepare(provider_name = nil)
  if provider_name
    container.prepare(provider_name)
  else
    prepare_slice
  end

  self
end

def prepare_all
  prepare_settings
  prepare_container_consts
  prepare_container_plugins
  prepare_container_base_config
  prepare_container_component_dirs
  prepare_container_imports
  prepare_container_providers
end

def prepare_autoloader
  # Component dirs are automatically pushed to the autoloader by dry-system's
  # zeitwerk plugin. This method adds other dirs that are not otherwise configured
  # as component dirs.

  # Everything in the slice root can be autoloaded except `config/` and `slices/`,
  # which are framework-managed directories

  if root.join(CONFIG_DIR)&.directory?
    autoloader.ignore(root.join(CONFIG_DIR))
  end

  if root.join(SLICES_DIR)&.directory?
    autoloader.ignore(root.join(SLICES_DIR))
  end

  autoloader.setup
end

def prepare_container_base_config
  container.config.name = slice_name.to_sym
  container.config.root = root
  container.config.provider_dirs = [File.join("config", "providers")]
  container.config.registrations_dir = File.join("config", "registrations")

  container.config.env = config.env
  container.config.inflector = config.inflector
end

def prepare_container_component_dirs
  return unless root.directory?

  # Component files in both the root and `lib/` define classes in the slice's
  # namespace

  if root.join(LIB_DIR)&.directory?
    container.config.component_dirs.add(LIB_DIR) do |dir|
      dir.namespaces.add_root(key: nil, const: slice_name.name)
    end
  end

  # When auto-registering components in the root, ignore files in `config/` (this is
  # for framework config only), `lib/` (these will be auto-registered as above), as
  # well as the configured no_auto_register_paths
  no_auto_register_paths = ([LIB_DIR, CONFIG_DIR] + config.no_auto_register_paths)
    .map { |path|
      path.end_with?(File::SEPARATOR) ? path : "#{path}#{File::SEPARATOR}"
    }

  # TODO: Change `""` (signifying the root) once dry-rb/dry-system#238 is resolved
  container.config.component_dirs.add("") do |dir|
    dir.namespaces.add_root(key: nil, const: slice_name.name)
    dir.auto_register = -> component {
      relative_path = component.file_path.relative_path_from(root).to_s
      !relative_path.start_with?(*no_auto_register_paths)
    }
  end
end

def prepare_container_consts
  namespace.const_set :Container, container
  namespace.const_set :Deps, container.injector
end

def prepare_container_imports
  import(
    keys: config.shared_app_component_keys,
    from: app.container,
    as: nil
  )
end

def prepare_container_plugins
  container.use(:env, inferrer: -> { Hanami.env })

  container.use(
    :zeitwerk,
    loader: autoloader,
    run_setup: false,
    eager_load: false
  )
end

def prepare_container_providers
  # Check here for the `routes` definition only, not `router` itself, because the
  # `router` requires the slice to be prepared before it can be loaded, and at this
  # point we're still in the process of preparing.
  if routes
    require_relative "providers/routes"
    register_provider(:routes, source: Providers::Routes.for_slice(self))
  end

  if assets_dir? && Hanami.bundled?("hanami-assets")
    require_relative "providers/assets"
    register_provider(:assets, source: Providers::Assets.for_slice(self))
  end
end

def prepare_settings
  container.register(:settings, settings) if settings
end

def prepare_slice
  return self if prepared?

  config.finalize!

  ensure_slice_name
  ensure_slice_consts
  ensure_root

  prepare_all

  instance_exec(container, &@prepare_container_block) if @prepare_container_block
  container.configured!

  prepare_autoloader

  # Load child slices last, ensuring their parent is fully prepared beforehand
  # (useful e.g. for slices that may wish to access constants defined in the
  # parent's autoloaded directories)
  prepare_slices

  @prepared = true

  self
end

def prepare_slices
  slices.load_slices.each(&:prepare)
  slices.freeze
end

def register_provider(...)
  container.register_provider(...)
end

def render_detailed_errors?
  config.render_detailed_errors && Hanami.bundled?("hanami-webconsole")
end

def render_errors?
  config.render_errors
end

def start(...)
  container.start(...)
end

def stop(...)
  container.stop(...)
end