admin_suite 0.3.1 → 0.5.0

data/lib/admin_suite/ui/form_field_renderer.rb

@@ -4,12 +4,9 @@ require "admin_suite/ui/field_renderer_registry"
 
 module AdminSuite
   module UI
-    # Overrides `render_form_field` to use a registry of field renderers,
-    # while leaving the legacy implementation available via `super`.
+    # Implements `render_form_field` using a registry of field renderers.
     module FormFieldRenderer
       def render_form_field(f, field, resource)
-        return super unless defined?(AdminSuite::UI::FieldRendererRegistry)
-
         return if field.if_condition.present? && !field.if_condition.call(resource)
         return if field.unless_condition.present? && field.unless_condition.call(resource)
 
@@ -33,9 +30,6 @@ module AdminSuite
                 field_class: field_class
               )
 
-            # If the registry doesn't know how to render, fall back to legacy behavior.
-            return super if field_html.nil?
-
             concat(field_html)
 
             concat(content_tag(:p, field.help, class: "mt-1 text-sm text-slate-500")) if field.help.present?

data/lib/admin_suite/ui/show_formatter_registry.rb

@@ -102,6 +102,15 @@ AdminSuite::UI::ShowFormatterRegistry.register_class(Float) do |value, view, _re
   view.content_tag(:span, view.number_with_delimiter(value), class: "font-mono")
 end
 
+AdminSuite::UI::ShowFormatterRegistry.register_class(BigDecimal) do |value, view, _record, _field|
+  # `.to_f` avoids number_with_delimiter rendering exponential notation
+  # (e.g. "0.98765e4") for BigDecimal input, at the cost of Float precision
+  # for values beyond Float's exact range (e.g. sub-cent monetary sums).
+  # That's an accepted display-only tradeoff here — don't "fix" this by
+  # dropping the conversion, or exponential notation comes back.
+  view.content_tag(:span, view.number_with_delimiter(value.to_f), class: "font-mono")
+end
+
 AdminSuite::UI::ShowFormatterRegistry.register_default do |value, view, _record, field_name|
   value_str = value.to_s
 

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.1"
+    VERSION = "0.5.0"
   end
 
   # Backward-compatible constant.

data/lib/admin_suite.rb

@@ -8,17 +8,65 @@ end
 
 require "pagy"
 
+# Hard dependency, declared in the gemspec but not a direct Gemfile entry in
+# any host -- Bundler's `Bundler.require` only auto-requires gems declared
+# directly in the Gemfile (or via `gemspec`'s own path entry), not a gem's
+# *transitive* runtime dependencies. Same reasoning as `pagy` above and
+# `redcarpet`/`rouge` in markdown_renderer.rb: required explicitly here so
+# `turbo_frame_tag`/`turbo_stream`/the `:turbo_stream` MIME type are real
+# regardless of what else the host's own Gemfile happens to require.
+require "turbo-rails"
+
 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 (removal targeted at 0.6.0, moved from the originally-planned
+# 0.5.0 -- both host migrations, gleania and trust_growth, are in flight):
+# 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/association_linking_test.rb

@@ -0,0 +1,292 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+# `LinkingFixtures::Company` (an AR-backed fixture: it genuinely subclasses
+# the `ActiveRecord::Base` stub defined in test_helper.rb) and its
+# registered `Admin::Resources::LinkingCompanyResource` both live in
+# test_helper.rb, not here -- established there because Tasks 4 and 7 reuse
+# them, and test_helper.rb is required by every test file regardless of
+# which single file `rake test TEST=...` runs. Everything below is specific
+# to this task's link-rendering assertions.
+module LinkingFixtures
+  # Same shape as Company, but deliberately never registered as an
+  # Admin::Resources::* class -- exercises the "no resource registered"
+  # degrade path in `auto_admin_suite_path_for`.
+  class UnregisteredVendor < ActiveRecord::Base
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name
+
+    def initialize(id: 3, name: "Ghost Vendor")
+      @id = id
+      @name = name
+    end
+
+    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) = new
+    def to_param = id.to_s
+    def attributes = { "id" => id, "name" => name }
+  end
+
+  # `item_display_title` calls `item.name` unguarded when `respond_to?(:name)`
+  # is true. This record's `#name` raises, simulating a host model whose
+  # display method blows up on bad data -- the point is that a single bad
+  # row must degrade, not 500 the entire page.
+  class RaisingCo < ActiveRecord::Base
+    extend ActiveModel::Naming
+
+    attr_reader :id
+
+    def initialize(id: 9)
+      @id = id
+    end
+
+    def name
+      raise "boom: no display name for you"
+    end
+
+    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) = new
+    def to_param = id.to_s
+    def attributes = { "id" => id }
+  end
+
+  # Simulates an unsaved/unpersisted AR record: real `ActiveRecord::Base#to_param`
+  # returns nil when `persisted?` is false. `auto_admin_suite_path_for`'s
+  # `resource_path(..., id: nil)` call must degrade to no-link, not 500.
+  class UnpersistedVendor < ActiveRecord::Base
+    extend ActiveModel::Naming
+
+    attr_reader :id, :name
+
+    def initialize
+      @id = nil
+      @name = "Draft Vendor"
+    end
+
+    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) = new
+    def to_param = nil
+    def attributes = { "id" => id, "name" => name }
+  end
+
+  # PORO host resource (mirrors the RedirectFixtures/ReadOnlyResourceFixtures
+  # convention). Its index column returns each of the AR values above, and
+  # its show page renders an association table where one column is itself an
+  # AR value -- the two call sites Task 3 unifies (`render_column_value`'s
+  # fallback branch and `format_table_cell`'s AR branch).
+  class Deal
+    extend ActiveModel::Naming
+
+    attr_reader :id, :label, :company
+
+    def initialize(id:, label:, company:)
+      @id = id
+      @label = label
+      @company = company
+    end
+
+    def self.all = ReadOnlyResourceFixtures::Relation.new([
+      new(id: 1, label: "Q3 renewal", company: Company.new),
+      new(id: 2, label: "Raises on display", company: RaisingCo.new),
+      new(id: 3, label: "Unpersisted vendor", company: UnpersistedVendor.new),
+      new(id: 4, label: "No resource registered", company: UnregisteredVendor.new)
+    ])
+    def self.column_names = %w[id label]
+    def self.primary_key = "id"
+    def self.columns_hash = { "id" => Struct.new(:type).new(:integer) }
+    def self.find(id) = all.find { |d| d.to_param == id.to_s }
+    def to_param = id.to_s
+    def attributes = { "id" => id, "label" => label }
+
+    def line_items
+      [
+        LineItem.new(1, "Renewal", Company.new),
+        LineItem.new(2, "Ghost line", UnregisteredVendor.new)
+      ]
+    end
+  end
+
+  LineItem = Struct.new(:id, :label, :company)
+
+  # Five deals, each pointing at a *distinct instance* of the *same*
+  # `LinkingFixtures::Company` class. `auto_admin_suite_path_for`'s registry
+  # lookup is keyed on `item.class`, not identity, so a correct memo
+  # resolves the resource once for this whole page -- pre-memo, each of
+  # the 5 rows independently re-ran the full registry scan.
+  class RepeatedCompanyDeal
+    extend ActiveModel::Naming
+
+    attr_reader :id, :label, :company
+
+    def initialize(id:, label:, company:)
+      @id = id
+      @label = label
+      @company = company
+    end
+
+    ROWS = Array.new(5) { |i| new(id: i + 1, label: "Deal #{i + 1}", company: Company.new(id: 100 + i, name: "Company #{i + 1}")) }
+
+    def self.all = ReadOnlyResourceFixtures::Relation.new(ROWS)
+    def self.column_names = %w[id label]
+    def self.primary_key = "id"
+    def self.columns_hash = { "id" => Struct.new(:type).new(:integer) }
+    def self.find(id) = all.find { |d| d.to_param == id.to_s }
+    def to_param = id.to_s
+    def attributes = { "id" => id, "label" => label }
+  end
+end
+
+module Admin
+  module Resources
+    class LinkingRepeatedCompanyDealResource < Admin::Base::Resource
+      model LinkingFixtures::RepeatedCompanyDeal
+      portal :ops
+      section :observability
+
+      index do
+        columns do
+          column :label
+          column :company
+        end
+      end
+    end
+
+    class LinkingRaisingCoResource < Admin::Base::Resource
+      model LinkingFixtures::RaisingCo
+      portal :ops
+      section :observability
+    end
+
+    class LinkingUnpersistedVendorResource < Admin::Base::Resource
+      model LinkingFixtures::UnpersistedVendor
+      portal :ops
+      section :observability
+    end
+
+    class LinkingDealResource < Admin::Base::Resource
+      model LinkingFixtures::Deal
+      portal :ops
+      section :observability
+
+      index do
+        columns do
+          column :label
+          column :company
+        end
+        # `Deal.all` is a `ReadOnlyResourceFixtures::Relation` -- it has no
+        # `#includes` method at all. This exercises Task 4's "skip
+        # silently, don't raise" path on every request this test file
+        # already makes to `/linking_deals`, not just a dedicated test.
+        includes :company
+      end
+
+      show do
+        section :line_items, association: :line_items, display: :table, columns: [ :label, :company ]
+      end
+    end
+  end
+end
+
+module AdminSuite
+  class AssociationLinkingTest < ActionDispatch::IntegrationTest
+    # ERB auto-escapes `<%= %>` output, so the literal bug string
+    # (`#<Company:0x...>`) never appears as raw `#<` in `response.body` --
+    # it shows up HTML-entity-escaped as `#&lt;LinkingFixtures::Company:0x...&gt;`.
+    # A `refute_includes response.body, "#<"` check would therefore pass
+    # vacuously against the *un*fixed code. Assert on the class-name leak
+    # itself instead, which survives escaping either way.
+    AR_INSPECT_LEAK = "LinkingFixtures::"
+
+    test "an index column returning an AR value links to that record's admin page" do
+      get "/internal/admin_suite/ops/linking_deals"
+      assert_response :success
+
+      refute_includes response.body, AR_INSPECT_LEAK
+      assert_includes response.body, "Acme Corp"
+      assert_match %r{<a[^>]+href="[^"]*linking_companies/7"[^>]*>\s*Acme Corp\s*</a>}, response.body
+    end
+
+    test "an AR value with a raising display title degrades instead of 500ing the page" do
+      get "/internal/admin_suite/ops/linking_deals"
+      assert_response :success
+      refute_includes response.body, AR_INSPECT_LEAK
+    end
+
+    test "an unpersisted AR record (to_param -> nil) renders plain text, not a broken link" do
+      get "/internal/admin_suite/ops/linking_deals"
+      assert_response :success
+      assert_includes response.body, "Draft Vendor"
+      refute_match %r{<a[^>]*>\s*Draft Vendor\s*</a>}, response.body
+    end
+
+    test "an AR value with no registered resource renders plain text, not a broken link" do
+      get "/internal/admin_suite/ops/linking_deals"
+      assert_response :success
+      assert_includes response.body, "Ghost Vendor"
+      refute_match %r{<a[^>]*>\s*Ghost Vendor\s*</a>}, response.body
+    end
+
+    test "an association table cell that is an AR value renders as a link too" do
+      get "/internal/admin_suite/ops/linking_deals/1"
+      assert_response :success
+
+      refute_includes response.body, AR_INSPECT_LEAK
+      assert_match %r{<a[^>]+href="[^"]*linking_companies/7"[^>]*>\s*Acme Corp\s*</a>}, response.body
+      # The second line item's company has no registered resource: plain text.
+      assert_includes response.body, "Ghost Vendor"
+      refute_match %r{<a[^>]*>\s*Ghost Vendor\s*</a>}, response.body
+    end
+
+    # Non-vacuous by construction: it counts actual invocations of
+    # `ensure_admin_resources_loaded_for!` -- called exactly once per
+    # registry *cache miss* inside `admin_suite_resource_for`, and nowhere
+    # else in the gem. (A page-wide spy on
+    # `Admin::Base::Resource.registered_resources` itself was tried first
+    # and rejected: navigation building calls it many more times per
+    # request for unrelated reasons -- e.g. `resources_for_portal` -- so
+    # that count is dominated by noise this task didn't touch.)
+    #
+    # Pre-memo, `auto_admin_suite_path_for` called
+    # `ensure_admin_resources_loaded_for!(item.class)` unconditionally on
+    # every invocation -- 5 rows of the same class meant 5 calls (and 2
+    # full registry scans apiece: the `.any?` inside it, plus the
+    # `registered_resources.find` right after). Memoized, only the first
+    # row's lookup is a cache miss; the other 4 hit
+    # `@admin_suite_resource_for` and never call this method at all -- so
+    # the call count for 5 rows must be 1, not 5. A test that only
+    # asserted "the memo hash is non-empty" would still pass if the memo
+    # were consulted but the scan ran unconditionally anyway; this asserts
+    # the scan was actually skipped.
+    test "auto_admin_suite_path_for memoizes the registry lookup per class, not per row" do
+      call_count = 0
+      helper_module = AdminSuite::BaseHelper
+      original_method = helper_module.instance_method(:ensure_admin_resources_loaded_for!)
+
+      helper_module.send(:define_method, :ensure_admin_resources_loaded_for!) do |model_class|
+        call_count += 1
+        original_method.bind(self).call(model_class)
+      end
+
+      begin
+        get "/internal/admin_suite/ops/linking_repeated_company_deals"
+        assert_response :success
+        assert_includes response.body, "Company 1"
+        assert_includes response.body, "Company 5"
+      ensure
+        helper_module.send(:define_method, :ensure_admin_resources_loaded_for!, original_method)
+      end
+
+      assert_equal 1, call_count,
+        "expected exactly one registry lookup for 5 rows of the same class (LinkingFixtures::Company) " \
+        "-- got #{call_count}, which means the memo isn't preventing a rescan per row"
+    end
+  end
+end