Add enum auto-detection for radios/checkboxes and default label text

When radios() or checkboxes() is called with no arguments, auto-detect
Rails enum options via Model.defined_enums and generate [key, humanized]
pairs. Explicit options always take precedence. Also make choice.label
without a block default to rendering choice.text.

Author: bradgessler

CHANGELOG.md

@@ -4,7 +4,9 @@
 
 - **Radio and checkbox groups** via `field(:plan).radios(...)` and `field(:roles).checkboxes(...)`.
   Accepts the same option formats as `select`. Each iteration yields a `Choice` with
-  `.radio`, `.checkbox`, `.label`, `.value`, `.text`.
+  `.radio`, `.checkbox`, `.label`, `.value`, `.text`. Auto-detects Rails enums when called
+  with no arguments — options are generated from `Model.defined_enums` with humanized labels.
+  `choice.label` without a block defaults to rendering `choice.text`.
 - **Hash options** for `select`, `radios`, and `checkboxes` — e.g. `radios(1 => "Basic", 2 => "Pro")`.
 - **Radio component** with `field(:gender).radio("male")` API. Automatically handles name, value, and checked state. Each radio gets a unique DOM id based on its value (e.g. `user_gender_male`).
 - **Checkbox collection support** — three modes:

README.md

@@ -384,23 +384,23 @@ class JobPostingForm < Components::Form
       Field(:remote_friendly).checkbox
     end
 
-    # Radio groups. Accepts all the same option formats as select:
-    # arrays, single values, hashes, or ActiveRecord relations.
+    # Radio group auto-detected from a Rails enum.
+    # Given: enum :employment_type, full_time: 0, part_time: 1, contract: 2
     fieldset do
       legend { "Employment type" }
-      field(:employment_type).radios(
-        "full_time" => "Full-time",
-        "part_time" => "Part-time",
-        "contract" => "Contract"
-      ).each do |choice|
+      field(:employment_type).radios.each do |choice|
         render choice.label {
           render choice.radio
           whitespace
-          plain choice.text
+          plain choice.text   # "Full time", "Part time", "Contract"
         }
       end
     end
 
+    # You can also pass explicit options to override enum detection.
+    # Accepts arrays, single values, hashes, or ActiveRecord relations.
+    # field(:employment_type).radios("full_time" => "Full-time", ...)
+
     # Checkbox groups. Same option formats, same Choice API.
     # Handles name[], checked state, and unique ids automatically.
     fieldset do

lib/superform/rails/choices.rb

@@ -32,8 +32,10 @@ def checkbox(**attributes)
           @field.checkbox(value: @value, index: @index, **attributes)
         end
 
-        def label(**attributes, &)
-          Components::Label.new(@field, for: DOM.join(@field.dom.id, @index), **attributes, &)
+        def label(**attributes, &block)
+          label_text = @text
+          block ||= proc { label_text }
+          Components::Label.new(@field, for: DOM.join(@field.dom.id, @index), **attributes, &block)
         end
       end
     end

lib/superform/rails/field.rb

@@ -148,10 +148,12 @@ def radio(value, index: value, **attributes)
       end
 
       def radios(*options)
+        options = enum_options if options.empty?
         Choices.new(field: self, options:)
       end
 
       def checkboxes(*options)
+        options = enum_options if options.empty?
         Choices.new(field: self, options:)
       end
 
@@ -162,6 +164,17 @@ def checkboxes(*options)
       def title
         key.to_s.titleize
       end
+
+      private
+
+      def enum_options
+        return [] unless object
+        enums = object.class.try(:defined_enums)
+        return [] unless enums
+        enum = enums[key.to_s]
+        return [] unless enum
+        enum.keys.map { |k| [k, k.humanize] }
+      end
     end
   end
 end

spec/superform/rails/choices_spec.rb

@@ -114,6 +114,82 @@
     end
   end
 
+  describe "enum auto-detection" do
+    let(:enum_class) do
+      Class.new do
+        def self.defined_enums
+          { "status" => { "draft" => 0, "published" => 1, "archived" => 2 } }
+        end
+
+        def self.try(method)
+          send(method) if respond_to?(method)
+        end
+      end
+    end
+    let(:object) { enum_class.new.tap { |o| o.define_singleton_method(:status) { "published" } } }
+    let(:field) { Superform::Rails::Field.new(:status, parent: nil, object: object) }
+
+    it "auto-detects enum options when no args given" do
+      choices = field.radios
+      values = choices.map { |c| [c.value, c.text] }
+      expect(values).to eq([["draft", "Draft"], ["published", "Published"], ["archived", "Archived"]])
+    end
+
+    it "checks the radio matching the current value" do
+      html = ""
+      field.radios.each do |choice|
+        html += render(choice.radio)
+      end
+
+      expect(html).to match(/<input[^>]*value="published"[^>]*checked/)
+      expect(html).not_to match(/<input[^>]*value="draft"[^>]*checked/)
+    end
+
+    it "uses explicit options when provided (skips enum)" do
+      choices = field.radios("active", "inactive")
+      values = choices.map { |c| [c.value, c.text] }
+      expect(values).to eq([["active", "active"], ["inactive", "inactive"]])
+    end
+
+    it "returns empty choices when field is not an enum" do
+      non_enum_field = Superform::Rails::Field.new(:name, parent: nil, object: object)
+      object.define_singleton_method(:name) { "test" }
+      choices = non_enum_field.radios
+      expect(choices.count).to eq(0)
+    end
+
+    it "returns empty choices when object is nil" do
+      nil_field = Superform::Rails::Field.new(:status, parent: nil, object: nil)
+      choices = nil_field.radios
+      expect(choices.count).to eq(0)
+    end
+
+    it "works with checkboxes too" do
+      choices = field.checkboxes
+      values = choices.map { |c| [c.value, c.text] }
+      expect(values).to eq([["draft", "Draft"], ["published", "Published"], ["archived", "Archived"]])
+    end
+  end
+
+  describe "default label text" do
+    let(:object) { double("object", plan_id: 1) }
+    let(:field) do
+      Superform::Rails::Field.new(:plan_id, parent: nil, object: object)
+    end
+
+    it "renders choice.text when label is called without a block" do
+      html = ""
+      field.radios([1, "Basic"], [2, "Pro"]).each do |choice|
+        html += render(choice.label)
+      end
+
+      expect(html).to include("Basic")
+      expect(html).to include("Pro")
+      expect(html).to include('for="plan_id_0"')
+      expect(html).to include('for="plan_id_1"')
+    end
+  end
+
   describe "is Enumerable" do
     let(:object) { double("object", status: "active") }
     let(:field) do