Add radios/checkboxes Choices API and hash option support

Introduce field(:plan).radios(...) and field(:roles).checkboxes(...)
for declarative radio and checkbox groups. Each yields a Choice with
.radio, .checkbox, .label, .value, .text. Accepts the same option
formats as select (arrays, single values, ActiveRecord relations)
plus hashes (e.g. {1 => "Basic", 2 => "Pro"}).

Refactor DOM#id to take no arguments, add DOM.join and DOM::DELIMITER
for centralized id construction. Radio and Checkbox components now
use index-based ids via DOM.join, with backward-compatible defaults.

Author: bradgessler

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ### 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`.
+- **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:
   - **Boolean** (on/off toggle): `Field(:featured).checkbox` renders with hidden "0" input

README.md

@@ -338,6 +338,7 @@ class SignupForm < Components::Form
     # Selects accept options as positional arguments. Each option can be:
     # - A 2-element array: [value, label] renders <option value="value">label</option>
     # - A single value: "text" renders <option value="text">text</option>
+    # - A hash: {1 => "Admin", 2 => "Editor"} maps ids to labels
     # - nil: renders an empty <option></option>
     div do
       Field(:contact).label { "Would you like us to spam you to death?" }
@@ -406,34 +407,40 @@ class SignupForm < Components::Form
       Field(:agreement).checkbox(checked: true)
     end
 
-    # Checkbox groups: loop over all possible options. Superform handles
-    # the name (with []), value, checked state, and unique ids. Each
-    # checkbox gets an id like "role_ids_1", "role_ids_2", etc.
+    # Radio groups: use radios(...) with the same option formats as select.
+    # Each iteration yields a Choice with .radio, .label, .value, .text.
+    # Ids are index-based: "plan_id_0", "plan_id_1", etc.
     fieldset do
-      legend { "Roles" }
-      Role.all.each do |role|
-        label(for: field(:role_ids).dom.id(role.id)) do
-          Field(:role_ids).checkbox(value: role.id)
+      legend { "Plan" }
+      field(:plan_id).radios([1, "Basic"], [2, "Pro"], [3, "Enterprise"]).each do |choice|
+        render choice.label {
+          render choice.radio
           whitespace
-          plain role.name
-        end
+          plain choice.text
+        }
       end
     end
 
-    # Radio groups: iterate your options and call radio(value) on the field.
-    # Superform handles the name, value, checked state, and unique ids automatically.
-    # Each radio gets an id like "plan_id_1", "plan_id_2", etc.
+    # Checkbox groups: use checkboxes(...) with the same option formats.
+    # Handles name[] and checked state automatically.
     fieldset do
-      legend { "Plan" }
-      Plan.all.each do |plan|
-        label(for: field(:plan_id).dom.id(plan.id)) do
-          Field(:plan_id).radio(plan.id)
+      legend { "Roles" }
+      field(:role_ids).checkboxes([1, "Admin"], [2, "Editor"], [3, "Viewer"]).each do |choice|
+        render choice.label {
+          render choice.checkbox
           whitespace
-          plain plan.name
-        end
+          plain choice.text
+        }
       end
     end
 
+    # Options also accept hashes: radios(1 => "Basic", 2 => "Pro")
+    # or ActiveRecord relations: radios(Plan.select(:id, :name))
+
+    # Low-level API: field(:gender).radio("male") and
+    # field(:role_ids).checkbox(value: 1) are still available
+    # for full control over iteration and ids.
+
     render button { "Submit" }
   end
 end

lib/superform/dom.rb

@@ -3,6 +3,12 @@ module Superform
   # norms that were established by Rails. These can be used outsidef or Rails in
   # other Ruby web frameworks since it has now dependencies on Rails.
   class DOM
+    DELIMITER = "_"
+
+    def self.join(*segments)
+      segments.join(DELIMITER)
+    end
+
     def initialize(field:)
       @field = field
     end
@@ -16,8 +22,8 @@ def value
     # Walks from the current node to the parent node, grabs the names, and seperates
     # them with a `_` for a DOM ID. One limitation of this approach is if multiple forms
     # exist on the same page, the ID may be duplicate.
-    def id(*suffixes)
-      (lineage.map(&:key) + suffixes).join("_")
+    def id
+      self.class.join(*lineage.map(&:key))
     end
 
     # The `name` attribute of a node, which is influenced by Rails (not sure where Rails got

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]).to_set
+                     [:dom, :value, :serialize, :assign, :collection, :field, :kit, :radios, :checkboxes]).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]).to_set
+                     [:dom, :value, :serialize, :assign, :collection, :field, :kit, :radios, :checkboxes]).to_set
       return if base_methods.include?(method_name)
       return if kit_class.method_defined?(method_name)
 

lib/superform/rails/choices.rb

@@ -0,0 +1,41 @@
+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, &)
+          Components::Label.new(@field, for: DOM.join(@field.dom.id, @index), **attributes, &)
+        end
+      end
+    end
+  end
+end

lib/superform/rails/components/checkbox.rb

@@ -2,6 +2,11 @@ module Superform
   module Rails
     module Components
       class Checkbox < Field
+        def initialize(field, index: nil, **attributes)
+          super(field, **attributes)
+          @index = index
+        end
+
         def view_template(&)
           if boolean?
             # Rails convention: hidden input ensures a value is sent even when unchecked
@@ -20,7 +25,7 @@ def field_attributes
           elsif collection?
             { id: dom.id, name: dom.name, checked: true }
           else
-            { id: dom.id(@attributes[:value]), name: dom.array_name, checked: Array(field.value).include?(@attributes[:value]) }
+            { id: DOM.join(dom.id, @index || @attributes[:value]), name: dom.array_name, checked: Array(field.value).include?(@attributes[:value]) }
           end
         end
 

lib/superform/rails/components/radio.rb

@@ -2,17 +2,18 @@ module Superform
   module Rails
     module Components
       class Radio < Field
-        def initialize(field, value:, **attributes)
+        def initialize(field, value:, index: value, **attributes)
           super(field, **attributes)
           @value = value
+          @index = index
         end
 
         def view_template(&)
           input(type: :radio, **attributes)
         end
 
         def field_attributes
-          { id: dom.id(@value), name: dom.name, value: @value, checked: field.value == @value }
+          { id: DOM.join(dom.id, @index), name: dom.name, value: @value, checked: field.value == @value }
         end
       end
     end

lib/superform/rails/field.rb

@@ -33,8 +33,8 @@ def input(**attributes)
         Components::Input.new(field, **attributes)
       end
 
-      def checkbox(**attributes)
-        Components::Checkbox.new(field, **attributes)
+      def checkbox(index: nil, **attributes)
+        Components::Checkbox.new(field, index:, **attributes)
       end
 
       def label(**attributes, &)
@@ -143,8 +143,16 @@ def file(*, **)
         input(*, **, type: :file)
       end
 
-      def radio(value, **attributes)
-        Components::Radio.new(field, value:, **attributes)
+      def radio(value, index: value, **attributes)
+        Components::Radio.new(field, value:, index:, **attributes)
+      end
+
+      def radios(*options)
+        Choices.new(field: self, options:)
+      end
+
+      def checkboxes(*options)
+        Choices.new(field: self, options:)
       end
 
       # Rails compatibility aliases

lib/superform/rails/option_mapper.rb

@@ -13,6 +13,8 @@ def each(&options)
           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

spec/superform/dom_spec.rb

@@ -73,10 +73,15 @@ def build_lineage(**lineage)
       expect(field.dom.id).to eq("grandparent_bars_baz")
     end
 
-    it "appends suffixes to the id" do
-      field = build_lineage(parent: Superform::Namespace, child: Superform::Field)
-      expect(field.dom.id("male")).to eq("parent_child_male")
-      expect(field.dom.id(1)).to eq("parent_child_1")
+  end
+
+  describe ".join" do
+    it "joins segments with the delimiter" do
+      expect(Superform::DOM.join("parent", "child", "male")).to eq("parent_child_male")
+    end
+
+    it "converts non-string segments" do
+      expect(Superform::DOM.join("parent", 1)).to eq("parent_1")
     end
   end
 end