Make radios/checkboxes renderable Phlex components

radios/checkboxes now return Phlex components instead of a Choices
enumerable. Without a block they render default label+input markup;
with a block they yield each Choice for custom layout. Kit auto-renders
them as one-liners.

Reorganize into Choices module: Choice::Choice holds per-option state,
Choice::Mapper (renamed from OptionMapper) maps args to (value, text)
pairs. Choice exposes a unified `input` method instead of separate
radio/checkbox methods — the type is set at construction.

Author: bradgessler

CHANGELOG.md

@@ -2,10 +2,12 @@
 
 ### Added
 
-- **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`. Auto-detects Rails enums when called
-  with no arguments — options are generated from `Model.defined_enums` with humanized labels.
+- **Radio and checkbox groups** via `Field(:plan).radios(...)` and `Field(:roles).checkboxes(...)`.
+  Now return renderable Phlex components (like `input`, `select`) so they work as one-liners
+  via Kit. Without a block, renders default `<label><input> Text</label>` markup per choice.
+  With a block, yields each `Choice` for custom markup — choice methods (`.input`,
+  `.label`) render directly into the component's output. Accepts the same option formats as
+  `select`. Auto-detects Rails enums when called with no arguments.
   `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`).

README.md

@@ -222,6 +222,40 @@ Then render it from Erb.
 
 Much better!
 
+### Customizing radios and checkboxes
+
+`radios` and `checkboxes` render sensible defaults out of the box, but you can subclass them to match your design system. Override `view_template` to change the default markup — the block form still works for one-off customizations.
+
+```ruby
+class Components::Form < Superform::Rails::Form
+  class MyRadios < Superform::Rails::Components::Radios
+    def view_template(&block)
+      choices.each do |choice|
+        if block
+          yield choice
+        else
+          div(class: "radio-option") do
+            render choice.build_radio(class: "radio-input")
+            label(for: DOM.join(dom.id, choice.index), class: "radio-label") do
+              plain choice.text
+            end
+          end
+        end
+      end
+    end
+  end
+
+  class Field < Field
+    def radios(*options, **attributes, &block)
+      options = enum_options if options.empty?
+      MyRadios.new(field, options:, **attributes, &block)
+    end
+  end
+end
+```
+
+Now every `Field(:status).radios` in your app gets the custom markup. Individual forms can still pass a block for one-off layouts.
+
 ## Namespaces & Collections
 
 Superform uses a different syntax for namespacing and collections than Rails, which can be a bit confusing since the same terminology is used but the application is slightly different.
@@ -370,7 +404,7 @@ class JobPostingForm < Components::Form
     end
 
     # ActiveRecord relations work as select options too.
-    # OptionMapper uses the primary key as value and joins remaining
+    # Choice::Mapper uses the primary key as value and joins remaining
     # attributes for the label.
     div do
       Field(:hiring_manager_id).label { "Hiring manager" }
@@ -386,11 +420,15 @@ class JobPostingForm < Components::Form
 
     # Radio group auto-detected from a Rails enum.
     # Given: enum :employment_type, full_time: 0, part_time: 1, contract: 2
+    # One-liner — renders <label><input type="radio"> Text</label> per choice.
+    Field(:employment_type).radios
+
+    # Block form — full control over each choice's markup.
     fieldset do
       legend { "Employment type" }
-      field(:employment_type).radios.each do |choice|
-        render choice.label {
-          render choice.radio
+      Field(:employment_type).radios do |choice|
+        choice.label {
+          choice.input
           whitespace
           plain choice.text   # "Full time", "Part time", "Contract"
         }
@@ -399,20 +437,29 @@ class JobPostingForm < Components::Form
 
     # 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", ...)
+    # Field(:employment_type).radios("full_time" => "Full-time", ...)
 
     # Checkbox groups. Same option formats, same Choice API.
     # Handles name[], checked state, and unique ids automatically.
+    # One-liner:
+    Field(:benefit_ids).checkboxes(
+      [1, "Health insurance"],
+      [2, "Dental & vision"],
+      [3, "401(k)"],
+      [4, "Stock options"]
+    )
+
+    # Block form:
     fieldset do
       legend { "Benefits" }
-      field(:benefit_ids).checkboxes(
+      Field(:benefit_ids).checkboxes(
         [1, "Health insurance"],
         [2, "Dental & vision"],
         [3, "401(k)"],
         [4, "Stock options"]
-      ).each do |choice|
-        render choice.label {
-          render choice.checkbox
+      ) do |choice|
+        choice.label {
+          choice.input
           whitespace
           plain choice.text
         }
@@ -544,12 +591,15 @@ Here's a checkbox group in Rails vs Superform. In Rails you need to manually wir
 ```
 
 ```ruby
-# Superform
+# Superform — one-liner
+Field(:benefit_ids).checkboxes(Benefit.select(:id, :name))
+
+# Or with custom markup
 fieldset do
   legend { "Benefits" }
-  field(:benefit_ids).checkboxes(Benefit.select(:id, :name)).each do |choice|
-    render choice.label {
-      render choice.checkbox
+  Field(:benefit_ids).checkboxes(Benefit.select(:id, :name)) do |choice|
+    choice.label {
+      choice.input
       whitespace
       plain choice.text
     }

lib/superform/field.rb

@@ -95,7 +95,7 @@ def kit(form)
 
     def self.copy_field_methods_to_kit(field_class, kit_class)
       base_methods = (Object.instance_methods + Node.instance_methods +
-                     [:dom, :value, :serialize, :assign, :collection, :field, :kit, :radios, :checkboxes]).to_set
+                     [:dom, :value, :serialize, :assign, :collection, :field, :kit]).to_set
 
       field_class.instance_methods(false).each do |method_name|
         next if method_name.to_s.end_with?('=')
@@ -113,7 +113,7 @@ def self.add_method_to_kit(method_name, kit_class)
       return if method_name.to_s.end_with?('=')
 
       base_methods = (Object.instance_methods + Node.instance_methods +
-                     [:dom, :value, :serialize, :assign, :collection, :field, :kit, :radios, :checkboxes]).to_set
+                     [:dom, :value, :serialize, :assign, :collection, :field, :kit]).to_set
       return if base_methods.include?(method_name)
       return if kit_class.method_defined?(method_name)
 

lib/superform/rails/choices.rb

@@ -1,43 +1,6 @@
 module Superform
   module Rails
-    class Choices
-      include Enumerable
-
-      def initialize(field:, options:)
-        @field = field
-        @options = options
-      end
-
-      def each(&)
-        OptionMapper.new(@options).each_with_index do |(value, text), index|
-          yield Choice.new(field: @field, value:, text:, index:)
-        end
-      end
-
-      class Choice
-        attr_reader :value, :text
-
-        def initialize(field:, value:, text:, index:)
-          @field = field
-          @value = value
-          @text = text
-          @index = index
-        end
-
-        def radio(**attributes)
-          @field.radio(@value, index: @index, **attributes)
-        end
-
-        def checkbox(**attributes)
-          @field.checkbox(value: @value, index: @index, **attributes)
-        end
-
-        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
+    module Choices
     end
   end
 end

lib/superform/rails/choices/choice.rb

@@ -0,0 +1,39 @@
+module Superform
+  module Rails
+    module Choices
+      class Choice
+        attr_reader :value, :text, :index
+
+        def initialize(component:, field:, value:, text:, index:, type:)
+          @component = component
+          @field = field
+          @value = value
+          @text = text
+          @index = index
+          @type = type
+        end
+
+        def input(**attrs)
+          @component.render build_input(**attrs)
+        end
+
+        def label(**attrs, &block)
+          label_text = @text
+          block ||= proc { label_text }
+          @component.render Components::Label.new(
+            @field, for: DOM.join(@field.dom.id, @index), **attrs, &block
+          )
+        end
+
+        def build_input(**attrs)
+          case @type
+          when :radio
+            Components::Radio.new(@field, value: @value, index: @index, **attrs)
+          when :checkbox
+            Components::Checkbox.new(@field, value: @value, index: @index, **attrs)
+          end
+        end
+      end
+    end
+  end
+end

lib/superform/rails/choices/mapper.rb

@@ -0,0 +1,41 @@
+module Superform
+  module Rails
+    module Choices
+      # Maps collections of options into (value, text) pairs for form controls.
+      # Accepts arrays, hashes, single values, and ActiveRecord relations.
+      class Mapper
+        include Enumerable
+
+        def initialize(collection)
+          @collection = collection
+        end
+
+        def each(&options)
+          @collection.each do |object|
+            case object
+              in ActiveRecord::Relation => relation
+                active_record_relation_options_enumerable(relation).each(&options)
+              in Hash => hash
+                hash.each { |id, value| options.call id, value }
+              in id, value
+                options.call id, value
+              in value
+                options.call value, value.to_s
+            end
+          end
+        end
+
+        def active_record_relation_options_enumerable(relation)
+          Enumerator.new do |collection|
+            relation.each do |object|
+              attributes = object.attributes
+              id = attributes.delete(relation.primary_key)
+              value = attributes.values.join(" ")
+              collection << [ id, value ]
+            end
+          end
+        end
+      end
+    end
+  end
+end

lib/superform/rails/components/checkboxes.rb

@@ -0,0 +1,38 @@
+module Superform
+  module Rails
+    module Components
+      class Checkboxes < Base
+        def initialize(field, options: [], **attributes)
+          super(field, **attributes)
+          @options = options
+        end
+
+        def view_template(&block)
+          choices.each do |choice|
+            if block
+              yield choice
+            else
+              label(for: DOM.join(dom.id, choice.index)) do
+                render choice.build_input
+                whitespace
+                plain choice.text
+              end
+            end
+          end
+        end
+
+        private
+
+        def choices
+          Choices::Mapper.new(@options).each_with_index.map do |(value, text), index|
+            Choices::Choice.new(component: self, field: @field, value:, text:, index:, type: :checkbox)
+          end
+        end
+
+        def field_attributes
+          {}
+        end
+      end
+    end
+  end
+end

lib/superform/rails/components/radios.rb

@@ -0,0 +1,38 @@
+module Superform
+  module Rails
+    module Components
+      class Radios < Base
+        def initialize(field, options: [], **attributes)
+          super(field, **attributes)
+          @options = options
+        end
+
+        def view_template(&block)
+          choices.each do |choice|
+            if block
+              yield choice
+            else
+              label(for: DOM.join(dom.id, choice.index)) do
+                render choice.build_input
+                whitespace
+                plain choice.text
+              end
+            end
+          end
+        end
+
+        private
+
+        def choices
+          Choices::Mapper.new(@options).each_with_index.map do |(value, text), index|
+            Choices::Choice.new(component: self, field: @field, value:, text:, index:, type: :radio)
+          end
+        end
+
+        def field_attributes
+          {}
+        end
+      end
+    end
+  end
+end

lib/superform/rails/components/select.rb

@@ -67,7 +67,7 @@ def false_option(&)
 
         protected
           def map_options(collection)
-            OptionMapper.new(collection)
+            Choices::Mapper.new(collection)
           end
 
           def field_attributes

lib/superform/rails/field.rb

@@ -147,14 +147,14 @@ def radio(value, index: value, **attributes)
         Components::Radio.new(field, value:, index:, **attributes)
       end
 
-      def radios(*options)
+      def radios(*options, **attributes, &block)
         options = enum_options if options.empty?
-        Choices.new(field: self, options:)
+        Components::Radios.new(field, options:, **attributes, &block)
       end
 
-      def checkboxes(*options)
+      def checkboxes(*options, **attributes, &block)
         options = enum_options if options.empty?
-        Choices.new(field: self, options:)
+        Components::Checkboxes.new(field, options:, **attributes, &block)
       end
 
       # Rails compatibility aliases