admin_suite 0.3.0 → 0.4.0

data/lib/admin_suite/ui/show_value_formatter.rb

@@ -4,8 +4,7 @@ require "admin_suite/ui/show_formatter_registry"
 
 module AdminSuite
   module UI
-    # Overrides `format_show_value` to use a registry of show value formatters,
-    # while leaving the legacy implementation available via `super`.
+    # Implements `format_show_value` using a registry of show value formatters.
     module ShowValueFormatter
       def format_show_value(record, field_name)
         value = record.public_send(field_name) rescue nil
@@ -70,7 +69,12 @@ module AdminSuite
 
         return formatted unless formatted.nil?
 
-        super
+        # Unreachable in practice: the registry's unconditional default
+        # handler always returns a value for any input, so `formatted` is
+        # never nil here. This is a last-resort guard, not a real code path
+        # — kept only in case a future handler is registered that returns
+        # nil, so rendering degrades to a plain span instead of raising.
+        content_tag(:span, value.to_s, class: "text-slate-900")
       end
 
       private

data/lib/admin_suite/version.rb

@@ -2,7 +2,7 @@
 
 module AdminSuite
   module Version
-    VERSION = "0.3.0"
+    VERSION = "0.4.0"
   end
 
   # Backward-compatible constant.

data/lib/admin_suite.rb

@@ -9,16 +9,53 @@ end
 require "pagy"
 
 require "admin_suite/version"
+require "admin_suite/deprecation"
 require "admin_suite/configuration"
 require "admin_suite/markdown_renderer"
 require "admin_suite/theme_palette"
 require "admin_suite/portal_registry"
+require "admin_suite/section_definition"
 require "admin_suite/portal_definition"
 require "admin_suite/auth"
 require "admin_suite/ui/form_field_renderer"
 require "admin_suite/ui/show_value_formatter"
+require "admin_suite/renderer"
+require "admin_suite/renderer_registry"
+require "admin_suite/renderers/json_renderer"
+require "admin_suite/renderers/key_value_renderer"
+require "admin_suite/renderers/table_from_renderer"
+require "admin_suite/renderers/code_renderer"
+require "admin_suite/renderers/legacy_gleania"
+require "admin_suite/legacy_custom_renderer_procs"
+require "admin_suite/definition_loader"
+require "admin_suite/host_autoload_policy"
 require "admin_suite/engine"
 
+# Registered as *defaults* (register_default), not explicit registrations:
+# `render_custom_section` checks a host's own `RendererRegistry.register`
+# call and a host's `Admin::Renderers::<Key>Renderer` class *before* falling
+# back to these, so a host following the deprecation advice below (or simply
+# overriding a built-in like `:json`) actually takes effect instead of being
+# silently shadowed by the gem's own boot-time registrations.
+AdminSuite::RendererRegistry.register_default(:json, AdminSuite::Renderers::JsonRenderer)
+AdminSuite::RendererRegistry.register_default(:key_value, AdminSuite::Renderers::KeyValueRenderer)
+AdminSuite::RendererRegistry.register_default(:table_from, AdminSuite::Renderers::TableFromRenderer)
+AdminSuite::RendererRegistry.register_default(:code, AdminSuite::Renderers::CodeRenderer)
+
+# Aliases: `:json_preview`/`:code_preview` were the previous generic
+# `render_custom_section` case branches (BaseHelper#render_json_preview /
+# #render_code_preview, now deleted). Host resources declared against those
+# keys keep working unchanged against the new built-in renderers.
+AdminSuite::RendererRegistry.register_default(:json_preview, AdminSuite::Renderers::JsonRenderer)
+AdminSuite::RendererRegistry.register_default(:code_preview, AdminSuite::Renderers::CodeRenderer)
+
+# Deprecated (removed in 0.5.0): the four Gleania-specific LLM chat-transcript
+# renderers. See `AdminSuite::Renderers::LegacyGleania` for details.
+AdminSuite::RendererRegistry.register_default(:prompt_template_preview, AdminSuite::Renderers::LegacyGleania::PromptTemplateRenderer)
+AdminSuite::RendererRegistry.register_default(:messages_preview, AdminSuite::Renderers::LegacyGleania::MessagesPreviewRenderer)
+AdminSuite::RendererRegistry.register_default(:tool_args_preview, AdminSuite::Renderers::LegacyGleania::ToolArgsRenderer)
+AdminSuite::RendererRegistry.register_default(:turn_messages_preview, AdminSuite::Renderers::LegacyGleania::TurnMessagesRenderer)
+
 module AdminSuite
   class << self
     # @return [AdminSuite::Configuration]

data/lib/generators/admin_suite/install/templates/admin_suite.rb

@@ -74,10 +74,6 @@ AdminSuite.configure do |config|
   # In apps that use Tailwind, this is typically `:app`.
   config.host_stylesheet = :app
 
-  # Tailwind CDN fallback (helps when host doesn't compile Tailwind).
-  # Disable if you provide your own Tailwind build.
-  config.tailwind_cdn = true
-
   # Optional docs link shown in the sidebar.
   # config.docs_url = "https://..."
   config.docs_url = nil

data/test/controllers/resources_controller_test.rb

@@ -5,7 +5,7 @@ require "test_helper"
 module AdminSuite
   class ResourcesControllerTest < ActiveSupport::TestCase
     class TestController < ResourcesController
-      attr_writer :test_resource_config
+      attr_writer :test_resource_config, :test_params
       attr_reader :filter_calls, :paginated_scope
 
       def initialize
@@ -13,6 +13,10 @@ module AdminSuite
         @filter_calls = 0
       end
 
+      def params
+        @test_params ||= {}
+      end
+
       private
 
       def resource_config
@@ -76,5 +80,76 @@ module AdminSuite
       assert_equal 37, controller.instance_variable_get(:@stats).second[:value]
       assert_equal :paginated, controller.instance_variable_get(:@collection)
     end
+
+    # Finding 3(a) of the whole-branch review: `set_resource`'s bare
+    # `rescue ActiveRecord::RecordNotFound` is the masking variant. In a host
+    # without ActiveRecord loaded, resolving that constant while dispatching
+    # an exception raises `NameError`, destroying whatever the real error
+    # was (here, a PORO model that doesn't implement `column_names`).
+    class PoroWithoutColumns
+      def self.column_names
+        raise NoMethodError, "undefined method 'column_names' for #{name}"
+      end
+    end
+
+    class PoroResourceConfig < Admin::Base::Resource
+      model PoroWithoutColumns
+    end
+
+    # A model shape that implements just enough of the ActiveRecord surface
+    # `set_resource`/`find_friendly_resource!` touch to exercise the genuine
+    # `ActiveRecord::RecordNotFound` recovery path end-to-end.
+    class SlugLookupModel
+      Column = Struct.new(:type)
+      Record = Struct.new(:id, :slug)
+
+      def self.column_names
+        %w[id slug]
+      end
+
+      def self.primary_key
+        "id"
+      end
+
+      def self.columns_hash
+        { "id" => Column.new(:string) }
+      end
+
+      def self.find(_id)
+        raise ActiveRecord::RecordNotFound, "not found by primary key"
+      end
+
+      def self.find_by(slug:)
+        slug == "the-slug" ? Record.new(42, "the-slug") : nil
+      end
+    end
+
+    class SlugResourceConfig < Admin::Base::Resource
+      model SlugLookupModel
+    end
+
+    test "set_resource still recovers via find_friendly_resource! on a genuine ActiveRecord::RecordNotFound" do
+      controller = TestController.new
+      controller.test_resource_config = SlugResourceConfig
+      controller.test_params = { id: "the-slug" }
+
+      controller.send(:set_resource)
+
+      assert_equal 42, controller.send(:resource).id
+    end
+
+    test "set_resource propagates the original error instead of masking it with NameError" do
+      controller = TestController.new
+      controller.test_resource_config = PoroResourceConfig
+      controller.test_params = { id: "1" }
+
+      original = ActiveRecord::RecordNotFound
+      ActiveRecord.send(:remove_const, :RecordNotFound)
+
+      error = assert_raises(NoMethodError) { controller.send(:set_resource) }
+      assert_match(/column_names/, error.message)
+    ensure
+      ActiveRecord.const_set(:RecordNotFound, original) unless defined?(ActiveRecord::RecordNotFound)
+    end
   end
 end

data/test/integration/dashboard_test.rb

@@ -65,5 +65,45 @@ module AdminSuite
       AdminSuite.config.root_dashboard_description = old_description
       AdminSuite.reset_root_dashboard!
     end
+
+    test "chart bars have a definite-height wrapper and preserve full labels" do
+      old_globs = AdminSuite.config.dashboard_globs
+
+      Dir.mktmpdir("admin-suite-chart") do |dir|
+        dashboard_rb = File.join(dir, "dashboard.rb")
+
+        File.write(dashboard_rb, <<~'RUBY')
+          # frozen_string_literal: true
+
+          AdminSuite.root_dashboard do
+            row do
+              chart_panel "Daily Cost", data: -> {
+                [
+                  { label: "Jul 30", value: 0.01 },
+                  { label: "Thursday", value: 10 }
+                ]
+              }
+            end
+          end
+        RUBY
+
+        AdminSuite.reset_root_dashboard!
+        AdminSuite.config.dashboard_globs = [ File.join(dir, "*.rb") ]
+
+        get "/internal/admin_suite"
+        assert_response :success
+
+        document = Nokogiri::HTML(response.body)
+        chart = document.at_xpath("//h3[normalize-space()='Daily Cost']/ancestor::div[contains(@class, 'rounded-xl')]")
+        assert chart
+        assert_equal 2, chart.css(".h-16 > .h-full").size
+        assert_equal ["height: 2%", "height: 100%"], chart.css(".h-16 > .h-full > div").map { |bar| bar["style"] }
+        assert_includes chart.text, "Jul 30"
+        assert_includes chart.text, "Thursday"
+      end
+    ensure
+      AdminSuite.config.dashboard_globs = old_globs
+      AdminSuite.reset_root_dashboard!
+    end
   end
 end

data/test/integration/layout_assets_test.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# A minimal ActiveModel-backed fixture with two markdown fields, registered
+# as a real resource so we can render an actual /new page through the full
+# stack and assert the vendored EasyMDE tags appear (not just that the files
+# exist on disk, and not just that a markdown-less page omits them).
+#
+# Per Task 9's ledger: `Admin::Base::Resource` subclasses register into a
+# process-global registry via `Class#inherited`, which fires once at class
+# definition (here, at file load) and never again -- so this is safe to
+# define at the top level like `ReadOnlyResourceFixtures`/`ReadOnlyWidgetResource`
+# in test/integration/read_only_resource_test.rb, and doesn't interact badly
+# with the nav-rebuild hazard documented there (this resource is never wiped
+# or reloaded mid-run).
+module LayoutAssetsFixtures
+  class MarkdownWidget
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    attr_accessor :id, :body, :notes
+
+    def initialize(id: nil, body: nil, notes: nil)
+      @id = id
+      @body = body
+      @notes = notes
+    end
+
+    def self.column_names
+      %w[id body notes]
+    end
+
+    def persisted?
+      !id.nil?
+    end
+
+    def new_record?
+      !persisted?
+    end
+
+    # render_form_field unconditionally calls `resource.errors[field.name]`
+    # (to add the error border class / message) for every field type; no
+    # test here exercises a validation error, so a Hash defaulting to `[]`
+    # is sufficient (same rationale as form_field_renderer_test.rb's Record).
+    def errors
+      Hash.new([])
+    end
+  end
+end
+
+module Admin
+  module Resources
+    class MarkdownWidgetResource < Admin::Base::Resource
+      model LayoutAssetsFixtures::MarkdownWidget
+      portal :ops
+      section :observability
+
+      # Two markdown fields on the same form: exercises the
+      # `content_for?(:easymde_assets)` dedup guard in
+      # AdminSuite::UI::FieldRendererRegistry's :markdown handler.
+      form do
+        field :body, type: :markdown
+        field :notes, type: :markdown
+      end
+    end
+  end
+end
+
+module AdminSuite
+  class LayoutAssetsTest < ActionDispatch::IntegrationTest
+    test "the admin layout requests no third-party CDN assets" do
+      get "/internal/admin_suite"
+      assert_response :success
+      refute_includes response.body, "cdn.jsdelivr.net"
+      refute_match(%r{<script[^>]+src="https?://(?!localhost)}, response.body)
+    end
+
+    test "EasyMDE ships as a vendored engine asset" do
+      assert AdminSuite::Engine.root.join("app/assets/vendor/easymde.min.js").exist?
+      assert AdminSuite::Engine.root.join("app/assets/vendor/easymde.min.css").exist?
+    end
+
+    test "the markdown controller bounds its editor-availability retry" do
+      js = AdminSuite::Engine.root.join("app/javascript/controllers/admin_suite/markdown_editor_controller.js").read
+      assert_match(/attempts|retries|maxWait/i, js)
+    end
+
+    test "a page rendering a markdown field loads the vendored EasyMDE assets, and still no CDN" do
+      get "/internal/admin_suite/ops/markdown_widgets/new"
+      assert_response :success
+
+      refute_includes response.body, "cdn.jsdelivr.net"
+      assert_match(%r{<link[^>]+href="[^"]*vendor/easymde\.min[^"]*\.css"}, response.body)
+      assert_match(%r{<script[^>]+src="[^"]*vendor/easymde\.min[^"]*\.js"}, response.body)
+    end
+
+    test "multiple markdown fields on one form emit the EasyMDE assets exactly once" do
+      get "/internal/admin_suite/ops/markdown_widgets/new"
+      assert_response :success
+
+      assert_equal 1, response.body.scan(%r{<link[^>]+href="[^"]*vendor/easymde\.min[^"]*\.css"}).size
+      assert_equal 1, response.body.scan(%r{<script[^>]+src="[^"]*vendor/easymde\.min[^"]*\.js"}).size
+    end
+
+    test "a page without a markdown field never references EasyMDE" do
+      get "/internal/admin_suite"
+      assert_response :success
+      refute_includes response.body, "vendor/easymde.min"
+    end
+  end
+end

data/test/integration/navigation_sections_test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AdminSuite
+  class NavigationSectionsTest < ActionDispatch::IntegrationTest
+    setup do
+      AdminSuite::PortalRegistry.reset!
+      AdminSuite.portal :ops do
+        label "Ops"
+        section :zzz_last do
+          label "Aaa Displayed First"
+          order 1
+        end
+        section :observability do
+          label "Observability"
+          order 50
+        end
+      end
+    end
+
+    teardown { AdminSuite::PortalRegistry.reset! }
+
+    test "declared sections use their label and order, not alphabetical keys" do
+      get "/internal/admin_suite/ops"
+      assert_response :success
+      first = response.body.index("Aaa Displayed First")
+      second = response.body.index("Observability")
+      assert first, "declared section label missing"
+      assert second, "second section label missing"
+      assert first < second, "sections must honour declared order, not label sort"
+    end
+
+    test "undeclared sections still auto-synthesize a humanized label" do
+      AdminSuite::PortalRegistry.reset!
+      get "/internal/admin_suite/ops"
+      assert_response :success
+      assert_includes response.body, "Observability" # from ReadOnlyWidgetResource's `section :observability`
+    end
+  end
+end

data/test/integration/pagination_and_stats_test.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# Self-contained fixture, following the pattern established in
+# authorization_test.rb/read_only_resource_test.rb: each integration test
+# file defines its own model + resource rather than depending on another
+# test file's fixture being loaded. Rake's TEST= support (rake/testtask.rb)
+# replaces the whole file list with just the one file requested, so a
+# fixture defined only in a sibling test file (e.g. ReadOnlyWidgetResource
+# in read_only_resource_test.rb) does not exist when this file is run in
+# isolation with `rake test TEST=test/integration/pagination_and_stats_test.rb`
+# (the exact command this task's brief calls for) — that dependency was a
+# plan-authored test defect, fixed here rather than in the implementation.
+module PaginationStatsFixtures
+  class Widget
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name
+
+    def initialize(id: 1, name: "Observed widget")
+      @id = id
+      @name = name
+    end
+
+    def self.all = ReadOnlyResourceFixtures::Relation.new((1..25).map { |n| new(id: n, name: "Observed widget #{n}") })
+    def self.column_names = %w[id name]
+    def self.primary_key = "id"
+    def self.columns_hash = { "id" => Struct.new(:type).new(:integer) }
+
+    def self.find(id)
+      raise ActiveRecord::RecordNotFound unless id.to_s == "1"
+
+      new
+    end
+
+    def to_param = id.to_s
+    def attributes = { "id" => id, "name" => name }
+
+    # A plain Array, not ReadOnlyResourceFixtures::Relation: render_association_section
+    # slices it via `Array.wrap(associated)[pagy.offset, per_page]` (the
+    # branch taken when the association doesn't respond to :offset), which
+    # exercises real pagination slicing rather than the Relation stand-in's
+    # no-op #offset/#limit.
+    def parts
+      (1..5).map { |n| Part.new(n) }
+    end
+  end
+
+  # Plain (non-ActiveRecord) associated record: exercises
+  # render_association_section's pagination path, the sole surviving caller
+  # of the deleted pagy_prev_link/pagy_next_link/pagy_page_links/
+  # render_pagy_series_item/render_association_pagination helpers.
+  class Part
+    attr_reader :id, :name
+
+    def initialize(id)
+      @id = id
+      @name = "Part #{id}"
+    end
+  end
+end
+
+module Admin
+  module Resources
+    class PaginationStatsWidgetResource < Admin::Base::Resource
+      model PaginationStatsFixtures::Widget
+      portal :ops
+      section :observability
+      read_only
+
+      index do
+        columns { column :name }
+        paginate 10
+        stats do
+          stat :total, -> { 7 }, color: :indigo
+        end
+      end
+
+      show do
+        section :parts, association: :parts, paginate: true, per_page: 2
+      end
+    end
+  end
+end
+
+module AdminSuite
+  class PaginationAndStatsTest < ActionDispatch::IntegrationTest
+    test "index stats render without dynamic tailwind color classes" do
+      get "/internal/admin_suite/ops/pagination_stats_widgets"
+      assert_response :success
+      refute_match(/class="[^"]*text-\{/, response.body)
+      # A real stat, with a real (new) color, rendered end to end through
+      # AdminSuite::UI::PanelDefinition + admin_suite/panels/_stat — not
+      # just a source-text check that the dynamic interpolation is gone.
+      assert_includes response.body, "text-indigo-700"
+      assert_includes response.body, ">7<"
+    end
+
+    test "the index stats markup comes from the shared stat partial" do
+      source = AdminSuite::Engine.root.join("app/views/admin_suite/resources/index.html.erb").read
+      refute_includes source, 'text-<%= color %>-600'
+      assert_includes source, "admin_suite/panels/stat"
+    end
+
+    test "pagination markup is a single shared partial" do
+      index = AdminSuite::Engine.root.join("app/views/admin_suite/resources/index.html.erb").read
+      helper = AdminSuite::Engine.root.join("app/helpers/admin_suite/base_helper.rb").read
+      assert_includes index, "admin_suite/shared/pagination"
+      refute_includes helper, "def pagy_prev_link"
+      refute_includes helper, "def render_pagy_series_item"
+    end
+
+    # The brief's original version of this test rendered the partial in
+    # isolation via `ApplicationController.render(partial:, locals:)`. That
+    # bare renderer has no routed request, so `params` carries no
+    # :controller/:action, and the partial's `url_for(params.permit!.merge(...))`
+    # calls (verbatim from the index view, per the brief's Step 3) raise
+    # `ActionController::UrlGenerationError: No route matches`. That is a
+    # second plan-authored test defect: fixed here by exercising the partial
+    # through a real routed request, which is how both callers (index,
+    # association panels) actually invoke it.
+    test "the shared pagination partial renders prev, next and the series" do
+      get "/internal/admin_suite/ops/pagination_stats_widgets", params: { page: 2 }
+      assert_response :success
+      assert_includes response.body, "Prev"
+      assert_includes response.body, "Next"
+      assert_includes response.body, "3"
+    end
+
+    test "association panel pagination renders through the same shared partial" do
+      get "/internal/admin_suite/ops/pagination_stats_widgets/1", params: { parts_page: 2 }
+      assert_response :success
+      assert_includes response.body, "Prev"
+      assert_includes response.body, "Next"
+      # Richer, index-derived markup that render_association_pagination
+      # (now deleted) never rendered: the "Showing X to Y of Z results"
+      # summary line (5 parts, 2 per page, page 2 => items 3-4).
+      assert_includes response.body, "Showing"
+      assert_includes response.body, "results"
+      assert_includes response.body, "3"
+      assert_includes response.body, "4"
+      assert_includes response.body, "5"
+      # The part most likely to regress: the per-association page param
+      # (association_page_param -> "#{section.association}_page"), not the
+      # generic :page the index uses.
+      assert_includes response.body, "parts_page=1"
+      assert_includes response.body, "parts_page=3"
+      refute_includes response.body, "?page=1"
+    end
+  end
+end

data/test/lib/action_executor_redirect_test.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module AdminSuite
+  class ActionExecutorRedirectTest < ActiveSupport::TestCase
+    Action = Struct.new(:name, :label, keyword_init: true)
+
+    test "AASM is not referenced as a bare constant" do
+      source = File.read(File.expand_path("../../lib/admin/base/action_executor.rb", __dir__))
+      refute_match(/rescue AASM::InvalidTransition/, source)
+    end
+
+    test "redirect target is derived for any action returning a persisted record" do
+      executor = Admin::Base::ActionExecutor.new(RedirectFixtures::WidgetResource, :clone_widget, nil)
+      url = executor.send(:redirect_url_for_action, Action.new(name: :clone_widget, label: "Clone"), RedirectFixtures::Widget.new)
+      assert_equal "/internal/admin_suite/ops/redirect_widgets/42", url
+    end
+
+    test "no redirect for results that are not persisted records" do
+      executor = Admin::Base::ActionExecutor.new(RedirectFixtures::WidgetResource, :ping, nil)
+      assert_nil executor.send(:redirect_url_for_action, Action.new(name: :ping, label: "Ping"), true)
+    end
+
+    test "a plain RuntimeError from a model action surfaces its real message, not a NameError" do
+      executor = Admin::Base::ActionExecutor.new(Admin::Resources::ExceptionHandlingBoomerResource, :kaboom, nil)
+      result = executor.execute_member(ExceptionHandlingFixtures::Boomer.new)
+
+      assert result.failure?
+      assert_equal "Error: actual failure message", result.message
+    end
+
+    test "an exception whose class name contains InvalidTransition is reported as a friendly failure" do
+      executor = Admin::Base::ActionExecutor.new(Admin::Resources::ExceptionHandlingStateMachineResource, :transition, nil)
+      result = executor.execute_member(ExceptionHandlingFixtures::StateMachineWidget.new)
+
+      assert result.failure?
+      assert_equal "Invalid state transition: cannot transition from draft to published", result.message
+    end
+  end
+end