admin_suite 0.3.1 → 0.4.0

data/lib/admin_suite/definition_loader.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  # Single glob-and-load implementation for the four families of definition
+  # files a host app may drop under its configured glob paths: resources,
+  # portals, root dashboards, and action handlers.
+  #
+  # Replaces five near-duplicate loaders (three in ApplicationController, one
+  # in BaseHelper, one in ActionExecutor) that each re-implemented the same
+  # glob -> require/load shape with three different reload policies and, in
+  # two cases, `rescue NameError; retry` used as control flow.
+  #
+  # Reload policy (uniform across all four kinds -- `load!` itself no longer
+  # branches on environment except for *how* a matching file gets loaded):
+  # - `loaded?` gates every call, in every environment: once a kind is
+  #   loaded, `load!(kind)` is a no-op until something explicitly clears it.
+  # - In development, matching files are loaded with `load` instead of
+  #   `require`; everywhere else, `require` (loaded once per process,
+  #   forever). This only matters for kinds that actually get reloaded a
+  #   second time -- `:resources` is excluded from that (see below), so for
+  #   resources `load` vs `require` is a distinction without a difference:
+  #   the file is read exactly once, same as pre-0.4.0.
+  # - Live-reload in development comes from *outside* `load!`: the engine's
+  #   "admin_suite.definition_reload" initializer hooks `reset_for_new_request!`
+  #   into `app.reloader.to_prepare`, which Rails runs once at boot and again
+  #   on any request where it detects a change in a watched path. That clears
+  #   the loaded flag (and, for kinds where it's safe, the registry) so the
+  #   *next* `load!` call re-globs and reloads -- at most once per such
+  #   request, not once per call. See `reset_for_new_request!` for why
+  #   `:resources` is deliberately excluded from that reset (and gets no
+  #   live-reload at all as a result).
+  #
+  # Error policy (generalized from ActionExecutor's pre-existing policy):
+  # log the failing file and error, then re-raise in development/test so
+  # broken definition files are immediately discoverable; swallow (after
+  # logging) elsewhere so one bad file doesn't take down a production boot
+  # or request.
+  class DefinitionLoader
+    # Maps each kind to:
+    # - glob_key:        the AdminSuite::Configuration attribute holding glob
+    #                     patterns for this kind.
+    # - reset:            clears this kind's registry/definition state. Used
+    #                     both by the test-facing `reset!` and, for
+    #                     `dev_resettable` kinds, by `reset_for_new_request!`.
+    # - loaded?:          true if this kind's definitions are already loaded.
+    #                     Gates every `load!` call, in every environment.
+    # - mark_loaded!:     records that a load attempt has completed. A no-op
+    #                     for kinds whose "loaded" state is self-evident from
+    #                     their registry (resources, portals): once something
+    #                     is registered, `loaded?` is already true. Kinds
+    #                     with no such registry (dashboards, actions) need an
+    #                     explicit flag so an all-empty-glob load doesn't
+    #                     re-scan the filesystem on every call.
+    # - dev_resettable:   whether `reset_for_new_request!` (the development
+    #                     live-reload hook) is allowed to reset this kind
+    #                     between requests. False only for :resources --
+    #                     see the comment on that entry.
+    KINDS = {
+      resources: {
+        glob_key: :resource_globs,
+        reset: -> { Admin::Base::Resource.reset_registry! },
+        loaded?: -> { Admin::Base::Resource.registered_resources.any? },
+        mark_loaded!: -> {},
+        # Resource registration happens *only* via `Class#inherited`
+        # (lib/admin/base/resource.rb), which fires on class *creation* and
+        # never on reopening an already-defined class. Resetting the
+        # registry and then `load`ing the same file again reopens the
+        # already-defined class -- `inherited` does not refire, so nothing
+        # re-populates the registry, and it stays empty for the rest of the
+        # process. This bit twice within a single request in production use
+        # (`navigation_items` is re-entered by `portal_color`/`portal_icon`
+        # while building the sidebar), wiping the nav on the very first
+        # request. So :resources is never reset -- not for a dev-mode
+        # reload, not ever.
+        #
+        # Consequence (this is a real cost, not a wash): resources are
+        # loaded once per process. Once `loaded?` is true, `load!(:resources)`
+        # never runs again, so the file is never re-read -- `load` (vs
+        # `require`) buys nothing here, unlike the other three kinds, because
+        # nothing ever calls it a second time. In development, both edits to
+        # an existing resource file and newly added resource files require a
+        # restart, unchanged from pre-0.4.0 behavior (which had no dev reload
+        # path for resources at all).
+        dev_resettable: false
+      },
+      portals: {
+        glob_key: :portal_globs,
+        reset: -> { AdminSuite::PortalRegistry.reset! },
+        loaded?: -> { AdminSuite::PortalRegistry.all.any? },
+        mark_loaded!: -> {},
+        dev_resettable: true
+      },
+      dashboards: {
+        glob_key: :dashboard_globs,
+        reset: -> { AdminSuite.reset_root_dashboard! },
+        loaded?: -> { AdminSuite.config.root_dashboard_loaded },
+        mark_loaded!: -> { AdminSuite.config.root_dashboard_loaded = true },
+        dev_resettable: true
+      },
+      actions: {
+        glob_key: :action_globs,
+        reset: -> { Admin::Base::ActionExecutor.handlers_loaded = false },
+        loaded?: -> { Admin::Base::ActionExecutor.handlers_loaded },
+        mark_loaded!: -> { Admin::Base::ActionExecutor.handlers_loaded = true },
+        dev_resettable: true
+      }
+    }.freeze
+
+    class << self
+      # Loads the definition files configured for `kind`, per the reload
+      # policy above. A no-op once `kind` is loaded, until something resets
+      # it (a test's explicit `reset!`, or -- in development -- the next
+      # `reset_for_new_request!` triggered by Rails' reloader).
+      #
+      # @param kind [Symbol] one of :resources, :portals, :dashboards, :actions
+      # @raise [ArgumentError] for an unrecognized kind
+      # @return [void]
+      def load!(kind)
+        entry = kind_entry(kind)
+        return if entry[:loaded?].call
+
+        files = glob_files(entry)
+        if files.empty?
+          entry[:mark_loaded!].call
+          return
+        end
+
+        load_files(files, mode: Rails.env.development? ? :load : :require)
+        entry[:mark_loaded!].call
+      end
+
+      # Resets `kind`'s registry/definition state unconditionally. Used by
+      # tests that need a clean slate regardless of `dev_resettable`.
+      #
+      # @param kind [Symbol]
+      # @return [void]
+      def reset!(kind)
+        kind_entry(kind)[:reset].call
+      end
+
+      # Clears every `dev_resettable` kind's loaded state, so the next
+      # `load!` call for each re-globs and reloads. Wired into
+      # `app.reloader.to_prepare` by the engine, in development only (see
+      # "admin_suite.definition_reload" in engine.rb) -- this is what turns
+      # "load once, cache forever" into "reload at most once per request"
+      # instead of `load!` resetting on every single call.
+      #
+      # :resources is deliberately skipped: see its KINDS entry.
+      #
+      # @return [void]
+      def reset_for_new_request!
+        KINDS.each_value { |entry| entry[:reset].call if entry[:dev_resettable] }
+      end
+
+      private
+
+      def kind_entry(kind)
+        KINDS.fetch(kind) do
+          raise ArgumentError, "unknown AdminSuite::DefinitionLoader kind: #{kind.inspect}"
+        end
+      end
+
+      def glob_files(entry)
+        Array(AdminSuite.config.public_send(entry[:glob_key])).flat_map { |glob| Dir[glob] }.uniq
+      end
+
+      def load_files(files, mode:)
+        files.each do |file|
+          begin
+            mode == :load ? load(file) : require(file)
+          rescue StandardError, ScriptError => e
+            log_error(file, e)
+            raise if Rails.env.development? || Rails.env.test?
+          end
+        end
+      end
+
+      def log_error(file, error)
+        message = "[AdminSuite] Failed to load definition file #{file}: #{error.class}: #{error.message}"
+
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.error(message)
+
+          backtrace = Array(error.backtrace).take(20).join("\n")
+          Rails.logger.error(backtrace) unless backtrace.empty?
+        else
+          warn(message)
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/lib/admin_suite/deprecation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  # Per-process, once-per-key deprecation warning support.
+  #
+  # Originally lived only on `AdminSuite::Renderers::LegacyGleania` (the four
+  # legacy Gleania renderers); pulled out here so `Admin::Base::Resource`
+  # (the `exportable` no-op) and the legacy `config.custom_renderers` proc
+  # path can share the same once-per-key behavior instead of re-implementing
+  # it, without becoming a general-purpose deprecation framework.
+  #
+  # `extend` this module to get an independent `@warned_keys` store scoped to
+  # the extending object (a module, or -- via singleton-method inheritance --
+  # each subclass of a class that extends it).
+  module Deprecation
+    # Swappable sink for the deprecation message -- a method rather than an
+    # attribute so `Minitest::Mock#stub(:warn_once_sink, replacement)` can
+    # intercept it directly: `stub` invokes the replacement with whatever
+    # arguments the stubbed call site passes (here, the message), rather
+    # than substituting it as a return value. Defaults to logging via
+    # `Rails.logger`.
+    #
+    # @param msg [String]
+    # @return [void]
+    def warn_once_sink(msg)
+      Rails.logger&.warn(msg)
+    end
+
+    # @return [void]
+    def reset_deprecation_notices!
+      @warned_keys = {}
+    end
+
+    # Fires the deprecation sink at most once per `key` per process (per
+    # extending object).
+    #
+    # @param key [Object] anything hashable identifying the deprecated thing
+    # @param message [String] fully-formatted deprecation message
+    # @return [void]
+    def warn_once(key, message)
+      @warned_keys ||= {}
+      return if @warned_keys[key]
+
+      @warned_keys[key] = true
+      warn_once_sink(message)
+    end
+  end
+end

data/lib/admin_suite/engine.rb

@@ -14,65 +14,7 @@ module AdminSuite
     end
 
     initializer "admin_suite.host_dsl_ignore", before: :setup_main_autoloader do |app|
-      # Host apps may store AdminSuite DSL files under `app/admin_suite/**` and
-      # `app/admin/portals/**`.
-      #
-      # These are side-effect DSL files (they do not define constants), so Zeitwerk
-      # must ignore them to avoid eager-load `Zeitwerk::NameError`s in production.
-
-      admin_suite_app_dir = Rails.root.join("app/admin_suite")
-      admin_dir = Rails.root.join("app/admin")
-      admin_portals_dir = Rails.root.join("app/admin/portals")
-
-      # If the host uses `Admin::*` constants inside `app/admin/**`, Rails' default
-      # autoload root (`app/admin`) would expect top-level constants like
-      # `Resources::UserResource`. We fix that by mapping `app/admin` to `Admin`.
-      # This avoids requiring host apps to add their own Zeitwerk initializer.
-      if admin_dir.exist? && self.class.host_admin_namespace_files?(admin_dir)
-        admin_dir_s = admin_dir.to_s
-        app.config.autoload_paths.delete(admin_dir_s)
-        app.config.eager_load_paths.delete(admin_dir_s)
-
-        # Ensure `Admin` exists so Zeitwerk can use it as a namespace.
-        module ::Admin; end
-
-        Rails.autoloaders.main.push_dir(admin_dir, namespace: ::Admin)
-      end
-
-      Rails.autoloaders.each do |loader|
-        loader.ignore(admin_suite_app_dir) if admin_suite_app_dir.exist?
-
-        next unless admin_portals_dir.exist?
-
-        loader.ignore(admin_portals_dir) if self.class.contains_admin_suite_portal_dsl?(admin_portals_dir)
-      end
-    end
-
-    def self.host_admin_namespace_files?(admin_dir)
-      # True if any file under app/admin appears to define `Admin::*` constants.
-      Dir[admin_dir.join("**/*.rb").to_s].any? do |file|
-        next false if file.include?("/portals/")
-
-        content = File.binread(file)
-        content = content.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
-
-        content.match?(/\b(module|class)\s+Admin\b/) ||
-          content.match?(/\b(module|class)\s+Admin::/)
-      rescue StandardError
-        false
-      end
-    end
-
-    def self.contains_admin_suite_portal_dsl?(admin_portals_dir)
-      portal_files = Dir[admin_portals_dir.join("**/*.rb").to_s]
-      portal_files.any? do |file|
-        content = File.binread(file)
-        content = content.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
-        portal_dsl_pattern = /(::)?AdminSuite\s*\.\s*portal\b/
-        portal_dsl_pattern.match?(content)
-      rescue StandardError
-        false
-      end
+      AdminSuite::HostAutoloadPolicy.apply!(app)
     end
 
     initializer "admin_suite.admin_dsl" do
@@ -83,17 +25,6 @@ module AdminSuite
       require "admin/base/action_handler"
     end
 
-    initializer "admin_suite.reloader" do |app|
-      # Reset the handlers_loaded flag in development so handlers are reloaded
-      # when code changes. This ensures the expensive glob operation happens at
-      # most once per request (or code reload) rather than on every NameError.
-      if Rails.env.development?
-        app.reloader.to_prepare do
-          Admin::Base::ActionExecutor.handlers_loaded = false
-        end
-      end
-    end
-
     initializer "admin_suite.watchable_dirs" do |app|
       next unless Rails.env.development?
 
@@ -103,6 +34,44 @@ module AdminSuite
       app.config.watchable_dirs[root.join("config").to_s] = %w[rb]
     end
 
+    initializer "admin_suite.host_watchable_dirs" do |app|
+      next unless Rails.env.development?
+
+      # Rails only re-runs `to_prepare` callbacks (see
+      # "admin_suite.definition_reload" below) when it detects a change in a
+      # watched path -- by default, `config.autoload_paths` +
+      # `eager_load_paths` + `watchable_files` + `watchable_dirs`.
+      # `app/admin*` directories are covered automatically (Rails treats
+      # every directory under `app/` as an autoload path). But
+      # `config/admin_suite/**` -- the *recommended*, deliberately
+      # non-autoload location for resource/portal/dashboard/action
+      # definitions (see "admin_suite.configuration" below) -- isn't in any
+      # of those by default, so editing only a file there would never be
+      # noticed. Watch it explicitly.
+      host_admin_suite_config_dir = Rails.root.join("config/admin_suite")
+      next unless host_admin_suite_config_dir.exist?
+
+      app.config.watchable_dirs[host_admin_suite_config_dir.to_s] = %w[rb]
+    end
+
+    initializer "admin_suite.definition_reload" do |app|
+      next unless Rails.env.development?
+
+      # Drives DefinitionLoader's development live-reload. Rails runs
+      # `to_prepare` callbacks once at boot and again on any request where
+      # it detects a change in a watched path (see
+      # "admin_suite.host_watchable_dirs" above) -- NOT unconditionally on
+      # every request (that's gated by `config.reload_classes_only_on_change`,
+      # true by default; see Rails::Application::Finisher#set_clear_dependencies_hook).
+      # Clearing the loaded flags here, rather than inside `load!` itself,
+      # is what bounds a reload to at most once per such request instead of
+      # once per `load!` call (application_controller.rb's `navigation_items`
+      # alone triggers several per request).
+      app.reloader.to_prepare do
+        AdminSuite::DefinitionLoader.reset_for_new_request!
+      end
+    end
+
     initializer "admin_suite.assets", before: "propshaft" do |app|
       # Make engine JS/CSS available to the host asset pipeline (Propshaft/Sprockets).
       app.config.assets.paths << root.join("app/javascript")
@@ -150,15 +119,25 @@ module AdminSuite
           ]
         end
 
-        config.portals = {
-          ops: { label: "Ops Portal", icon: "settings", color: :amber, order: 10 },
-          email: { label: "Email Portal", icon: "inbox", color: :emerald, order: 20 },
-          ai: { label: "AI Portal", icon: "cpu", color: :cyan, order: 30 },
-          assistant: { label: "Assistant Portal", icon: "message-circle", color: :violet, order: 40 }
-        } if config.portals.blank?
+        self.class.apply_default_portals!(config)
       end
     end
 
+    # Applies the engine's built-in default portals, unless the host has
+    # explicitly assigned `config.portals` itself (even to `{}`). Extracted
+    # from the "admin_suite.configuration" initializer so it is directly
+    # testable without booting a full Rails app.
+    def self.apply_default_portals!(config)
+      return if config.portals_configured? || config.portals.present?
+
+      config.send(:default_portals!, {
+        ops: { label: "Ops Portal", icon: "settings", color: :amber, order: 10 },
+        email: { label: "Email Portal", icon: "inbox", color: :emerald, order: 20 },
+        ai: { label: "AI Portal", icon: "cpu", color: :cyan, order: 30 },
+        assistant: { label: "Assistant Portal", icon: "message-circle", color: :violet, order: 40 }
+      })
+    end
+
     initializer "admin_suite.tailwind_build" do
       next unless Rails.env.development?
 

data/lib/admin_suite/host_autoload_policy.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  # Zeitwerk integration for host apps, extracted from the engine's
+  # "admin_suite.host_dsl_ignore" initializer so it is directly testable
+  # against the real Zeitwerk-loader interface instead of a copy of it.
+  #
+  # Host apps may store AdminSuite DSL files under `app/admin_suite/**` and
+  # `app/admin/portals/**`. These are side-effect DSL files (they do not
+  # define constants), so Zeitwerk must ignore them to avoid eager-load
+  # `Zeitwerk::NameError`s in production. Host apps may also use `Admin::*`
+  # constants inside `app/admin/**`, which needs a namespace mapping since
+  # Rails' default autoload root (`app/admin`) otherwise expects top-level
+  # constants.
+  class HostAutoloadPolicy
+    class << self
+      # @param app [Rails::Application] the host application
+      # @param loaders [#each, #main] defaults to `Rails.autoloaders`. Tests
+      #   may inject a plain Array of fake loaders; `main` is used for
+      #   `push_dir` (falling back to the first loader when the given
+      #   collection doesn't respond to `#main`) and every loader in the
+      #   collection is given a chance to `#ignore` the DSL directories.
+      # @return [void]
+      def apply!(app, loaders: Rails.autoloaders)
+        root = app.root
+
+        admin_suite_app_dir = root.join("app/admin_suite")
+        admin_dir = root.join("app/admin")
+        admin_portals_dir = root.join("app/admin/portals")
+
+        # If the host uses `Admin::*` constants inside `app/admin/**`, Rails' default
+        # autoload root (`app/admin`) would expect top-level constants like
+        # `Resources::UserResource`. We fix that by mapping `app/admin` to `Admin`.
+        # This avoids requiring host apps to add their own Zeitwerk initializer.
+        admin_dir_mapped = admin_dir.exist? && host_admin_namespace_files?(admin_dir)
+
+        if admin_dir_mapped
+          admin_dir_s = admin_dir.to_s
+          app.config.autoload_paths.delete(admin_dir_s)
+          app.config.eager_load_paths.delete(admin_dir_s)
+
+          # Ensure `Admin` exists so Zeitwerk can use it as a namespace.
+          ensure_module!(Object, :Admin)
+
+          main_loader(loaders).push_dir(admin_dir, namespace: ::Admin)
+          # `app/admin/renderers/foo_renderer.rb` now resolves to
+          # `Admin::Renderers::FooRenderer` under this same push_dir, with no
+          # extra work: the whole `app/admin` tree (including `renderers/`) is
+          # namespaced under `::Admin` by Zeitwerk's directory conventions.
+        end
+
+        # A host with ONLY DSL files under `app/admin` (no `Admin::*` constants
+        # anywhere) never takes the branch above, so `app/admin` remains a
+        # default Rails autoload root mapping to top-level constants. Without
+        # this, `app/admin/renderers/foo_renderer.rb` would need to define a
+        # top-level `Renderers::FooRenderer` instead of the documented
+        # `Admin::Renderers::FooRenderer`, and `host_renderer_class` in
+        # base_helper.rb would never find it. Map `app/admin/renderers`
+        # explicitly in that case.
+        renderers_dir = root.join("app/admin/renderers")
+        if renderers_dir.exist? && !admin_dir_mapped
+          ensure_module!(Object, :Admin)
+          ensure_module!(::Admin, :Renderers)
+          main_loader(loaders).push_dir(renderers_dir, namespace: ::Admin::Renderers)
+        end
+
+        each_loader(loaders) do |loader|
+          loader.ignore(admin_suite_app_dir) if admin_suite_app_dir.exist?
+
+          next unless admin_portals_dir.exist?
+
+          loader.ignore(admin_portals_dir) if contains_admin_suite_portal_dsl?(admin_portals_dir)
+        end
+      end
+
+      # True if any file under app/admin (excluding app/admin/portals)
+      # appears to define `Admin::*` constants.
+      #
+      # @param admin_dir [Pathname]
+      # @return [Boolean]
+      def host_admin_namespace_files?(admin_dir)
+        Dir[admin_dir.join("**/*.rb").to_s].any? do |file|
+          next false if file.include?("/portals/")
+
+          content = File.binread(file)
+          content = content.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+
+          content.match?(/\b(module|class)\s+Admin\b/) ||
+            content.match?(/\b(module|class)\s+Admin::/)
+        rescue StandardError
+          false
+        end
+      end
+
+      # True if any file under `admin_portals_dir` uses the `AdminSuite.portal`
+      # DSL (as opposed to defining real constants).
+      #
+      # @param admin_portals_dir [Pathname]
+      # @return [Boolean]
+      def contains_admin_suite_portal_dsl?(admin_portals_dir)
+        portal_files = Dir[admin_portals_dir.join("**/*.rb").to_s]
+        portal_files.any? do |file|
+          content = File.binread(file)
+          content = content.encode("UTF-8", invalid: :replace, undef: :replace, replace: "")
+          portal_dsl_pattern = /(::)?AdminSuite\s*\.\s*portal\b/
+          portal_dsl_pattern.match?(content)
+        rescue StandardError
+          false
+        end
+      end
+
+      private
+
+      def main_loader(loaders)
+        loaders.respond_to?(:main) ? loaders.main : Array(loaders).first
+      end
+
+      # `module Foo; end` can't appear inside a method body (it's a syntax
+      # error there, unlike inside a block), so namespace creation goes
+      # through `const_set` instead.
+      def ensure_module!(parent, name)
+        return if parent.const_defined?(name, false)
+
+        parent.const_set(name, Module.new)
+      end
+
+      def each_loader(loaders, &block)
+        loaders.each(&block)
+      end
+    end
+  end
+end

data/lib/admin_suite/legacy_custom_renderer_procs.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module AdminSuite
+  # Deprecation warning for `config.custom_renderers[:key] = ->(record, view) {}`
+  # procs (deprecated on paper since 0.4.0 — see CHANGELOG). They still take
+  # top precedence in `render_custom_section`, unchanged: Task 3 has tests
+  # pinning that. Unlike the four legacy Gleania renderers, though, these
+  # warned nothing at runtime, so a host mid-migration (trust_growth has 23
+  # of them) has no signal to notice by. Warns once per key per process.
+  module LegacyCustomRendererProcs
+    extend AdminSuite::Deprecation
+
+    DEPRECATION_MESSAGE_FORMAT =
+      "AdminSuite: config.custom_renderers[:%<key>s] is a deprecated proc " \
+      "and will be removed in 0.5.0. Migrate to an AdminSuite::Renderer subclass."
+
+    class << self
+      # Fires the deprecation sink at most once per `key` per process.
+      # `warn_once_sink` and `reset_deprecation_notices!` come from
+      # `AdminSuite::Deprecation`, extended above.
+      #
+      # @param key [Symbol]
+      # @return [void]
+      def warn_once(key)
+        super(key, format(DEPRECATION_MESSAGE_FORMAT, key: key))
+      end
+    end
+  end
+end

data/lib/admin_suite/portal_definition.rb

@@ -14,6 +14,7 @@ module AdminSuite
       @order = nil
       @description = nil
       @dashboard = nil
+      @sections = {}
     end
 
     def label(value = nil)
@@ -51,6 +52,16 @@ module AdminSuite
       @dashboard
     end
 
+    def section(key, &block)
+      definition = (@sections[key.to_sym] ||= SectionDefinition.new(key))
+      definition.instance_eval(&block) if block_given?
+      definition
+    end
+
+    def sections
+      @sections
+    end
+
     def to_nav_meta
       {
         label: @label,