phlex-forms 0.2.3 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 536c63a40e17d971808a285a30d6bd8a96a0f0049ecdd1fc2472e39d2359337b
-  data.tar.gz: 81460e049eccf72d1181420e705834b111bcd64aa5e4865f04fa811350c423f1
+  metadata.gz: 74bd32547d30535c35060ea6c93f9cfd199614a9ced2cf1a95a7c32fe62eb3e6
+  data.tar.gz: cf0087d9bee7cb13366ef489fb8764c82867b406881934eb92cdb7dbc271d0f8
 SHA512:
-  metadata.gz: 1479141adae7a0f38ed945d1cd572b6a1ad6c0504964d6690e0f4db1ed1a901f8f9ba99c6e2af497020bce01adbca8fbe1ab36c46f59815296c6b46bc894f482
-  data.tar.gz: a72f1a2367fc0e0ddcc155241805e5c70943c7d11ebe5a08ad88f2e33f2094e7a03b14ecbd61fc4f205072f0473f3e6ba9cf5413ed3ce3a8313a920db5309d1e
+  metadata.gz: 33980ae64283b549a82ab25bd445df927616ac7bc5d0929c41aba13c10439d795c631268e6154bd64a5c0b9783baee4573e7e4efdeef7ecd3e8ac4633791b1bd
+  data.tar.gz: d4d4efd19dd0dbde90311922d91040052925a87948cdcd95d42b50049028186a6cd1b7b80a8b7027154cadd67e8801ad242777817a1ab214d13088e40a5558b3

data/CHANGELOG.md

@@ -9,6 +9,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **`checkbox_group` — batched checkbox group for array-valued fields** (the
+  tag/facet-picker shape): `f.checkbox_group(:tag_ids, Tag.all, value: :id,
+  label: :name, variant: :pill, size: :sm)`, or via field inference
+  (`f.field :tag_ids, as: :checkbox_group, collection: Tag.all, value: :id`).
+  Shares one array-valued field name with a leading empty-array hidden field,
+  derives the checked set from the model's current value, and renders under both
+  themes. `variant:` (`:stack`/`:inline`/`:pill`) is layout-only, no JS.
+
+### Changed
+
+- **Client-side validation Stimulus identifiers dropped the `forms--` prefix**:
+  the bundled controllers now emit `validations--presence`, `validations--length`,
+  … (and the `validations--form` coordinator) so
+  `lazyLoadControllersFrom("phlex_forms/controllers")` resolves them to their
+  shipped path `phlex_forms/controllers/validations/*_controller` — previously
+  `forms--validations--*` derived `.../forms/validations/*`, which 404'd and the
+  controllers never connected (issue #12). The `data-validations--*` binding
+  attributes and the `invalidate:validations` event changed to match. Hosts that
+  registered `forms--validations--*` explicitly must update the identifier.
+
+### Fixed
+
+- **`f.Radio` / `Field#radio` rendered the model's current value on every radio
+  instead of each radio's own value**: `field_attributes` carried `value:
+  field_value` and was splatted after the explicit positional value, clobbering
+  it — a new record lost the value entirely, an edit form gave every radio the
+  same value. `radio` now drops `field_attributes`' `value` (issue #13).
+- **`Form(validate: true)` never fired client-side validation on submit**: the
+  coordinator controller was attached but no `data-action` wired its `onSubmit`
+  handler, so submitting an invalid form was not blocked. `apply_validation_coordinator`
+  now emits `submit->validations--form#onSubmit` (joined with any
+  caller-supplied `data-action`).
+- **`fields_for` iterated a Hash-backed association (JSONB), emitting bogus
+  indices**: a Hash responds to `#each_with_index`, so a JSONB column rendered
+  with `nested_attributes: false` produced `scope[assoc][0][field]`, `[1]`, …
+  instead of a single `scope[assoc][field]`. It is now treated as a single
+  nested scope; only genuine collections (Enumerable, not Hash) iterate.
+
 - **`Forms::Base` declarative form classes**: subclass, declare fields in
   `#fields` where `self` IS the form (bare `field :email`, no `f.` prefix),
   render with `render UserForm.new(model: @user)`. Class-level `form_options`

data/README.md

@@ -337,6 +337,11 @@ import { lazyLoadControllersFrom } from "@hotwired/stimulus-loading"
 lazyLoadControllersFrom("phlex_forms/controllers", application)
 ```
 
+The emitted identifiers are `validations--presence`, `validations--length`, … (and
+the form-level `validations--form` coordinator), which `lazyLoadControllersFrom`
+resolves to `phlex_forms/controllers/validations/*_controller` — the path the gem
+ships them at.
+
 Messages ship for `en` / `fr` / `af`; override via `window.PhlexForms.messages`.
 
 ## Nested attributes, collections & escape valves
@@ -351,13 +356,29 @@ f.fields_for(:settings, nested_attributes: false) do |s|
 end
 
 f.collection_check_boxes(:role_ids, Role.all, :id, :name) do |b|
-  render b.check_box
+  render b.check_box                          # per-item control, full custom layout
   render b.label
 end
 
+# The batched "tag/facet picker" shape: one array-valued field name, checked
+# state derived from the model (record.tag_ids), sensible defaults, no block.
+f.checkbox_group(:tag_ids, Tag.all, value: :id, label: :name)
+f.checkbox_group(:tag_ids, Tag.all, value: :id,
+  label: ->(t) { t.name.presence || t.slug }, # Symbol method or Proc
+  variant: :pill,                             # :stack (default) | :inline | :pill
+  size: :sm)                                  # daisyUI checkbox size
+# ...or through field inference:
+f.field :tag_ids, as: :checkbox_group, collection: Tag.all, value: :id, label: :name
+
 f.collection_select(:country_id, Country.all, :id, :name, prompt: "Select…")
 ```
 
+`checkbox_group` submits an array param (`user[tag_ids][]`) with a leading
+empty-array hidden field, so deselecting everything still submits. The checked
+set comes from the model's current value matched by each item's resolved
+`value:` — re-rendering an edit form pre-checks the right boxes. The `:pill`
+variant styles the active chip with Tailwind's `has-[:checked]:` (no JS).
+
 `Form(model: @item, scope: false)` emits **bare** field names
 (`name="quantity"`) — the shape phlex-reactive row editors and
 `<template>`-cloned rows need. External widgets bind through the public

data/app/javascript/phlex_forms/controllers/validations/base_controller.js

@@ -10,7 +10,7 @@ import { Controller } from "@hotwired/stimulus"
 // reads from data attributes; the base class only knows about the
 // `allowBlank` / `allowNil` short-circuits.
 export class FieldValidatorController extends Controller {
-  // `error` is opt-in: callers that pre-render a `<p data-forms--validations--error-target="error">`
+  // `error` is opt-in: callers that pre-render a `<p data-validations--<validator>-target="error">`
   // get a stable slot the controller toggles. Inputs without an
   // explicit target still work — the controller lazily creates one
   // adjacent to the input below.
@@ -24,12 +24,12 @@ export class FieldValidatorController extends Controller {
   // directly to <input>, <textarea>, <select> via the form builder.
   connect() {
     this.element.addEventListener("blur", this.onBlur)
-    this.element.addEventListener("invalidate:forms--validations", this.onValidate)
+    this.element.addEventListener("invalidate:validations", this.onValidate)
   }
 
   disconnect() {
     this.element.removeEventListener("blur", this.onBlur)
-    this.element.removeEventListener("invalidate:forms--validations", this.onValidate)
+    this.element.removeEventListener("invalidate:validations", this.onValidate)
   }
 
   onBlur = () => {
@@ -150,7 +150,7 @@ export class FieldValidatorController extends Controller {
     // adjacent to the input. Keeps the framework usable on plain
     // forms that haven't opted into the static-target convention.
     const id = this.element.id || this.element.name
-    const selector = `[data-forms--validations--error="${id}"]`
+    const selector = `[data-validations--error="${id}"]`
     const existing = this.element.closest("form")?.querySelector(selector)
     if (existing) return existing
     if (!create) return null
@@ -159,7 +159,7 @@ export class FieldValidatorController extends Controller {
     container.className = "text-error text-sm mt-1"
     // `dataset` rejects keys with `--`, so we set the attribute
     // directly. The CSS selector still matches.
-    container.setAttribute("data-forms--validations--error", id)
+    container.setAttribute("data-validations--error", id)
     this.element.insertAdjacentElement("afterend", container)
     return container
   }

data/app/javascript/phlex_forms/controllers/validations/form_controller.js

@@ -3,7 +3,7 @@ import { Controller } from "@hotwired/stimulus"
 // Form-level coordinator for the validation framework. Sits on the
 // <form> element and intercepts `submit` to broadcast a synchronous
 // validation event to every field. Each field controller listens
-// for `invalidate:forms--validations`, runs its check, and (on
+// for `invalidate:validations`, runs its check, and (on
 // failure) appends its error to the event's `detail.errors` array.
 // If anything ended up in that array, we cancel the submit and
 // focus the first invalid field.
@@ -23,11 +23,11 @@ export default class extends Controller {
     fields.forEach((field) => {
       const validators = (field.dataset.controller || "")
         .split(/\s+/)
-        .filter((c) => c.startsWith("forms--validations--") && c !== "forms--validations--form")
+        .filter((c) => c.startsWith("validations--") && c !== "validations--form")
       if (validators.length === 0) return
 
       field.dispatchEvent(
-        new CustomEvent("invalidate:forms--validations", {
+        new CustomEvent("invalidate:validations", {
           detail: { errors },
         }),
       )

data/app/javascript/phlex_forms/controllers/validations/length_controller.js

@@ -12,7 +12,7 @@ export default class extends FieldValidatorController {
   // Stimulus walks the prototype chain to accumulate `static values`
   // and `static targets`, so we only declare the validator-specific
   // ones here. `counter` is opt-in: callers that pre-render
-  // `<span data-forms--validations--length-target="counter">` get a
+  // `<span data-validations--length-target="counter">` get a
   // stable slot the controller updates. Inputs without an explicit
   // target still get a lazily-injected one (see counterElement).
   static targets = ["counter"]
@@ -80,7 +80,7 @@ export default class extends FieldValidatorController {
 
     // Fallback: cache-by-id lookup or lazy injection for plain forms.
     const id = this.element.id || this.element.name
-    const selector = `[data-forms--validations--counter="${id}"]`
+    const selector = `[data-validations--counter="${id}"]`
     const existing = this.element.closest("form")?.querySelector(selector)
     if (existing) return existing
     if (!create) return null
@@ -88,7 +88,7 @@ export default class extends FieldValidatorController {
     const counter = document.createElement("span")
     counter.className = "text-xs text-base-content/60 ml-auto"
     // `dataset` rejects keys containing `--`; use the raw attribute API.
-    counter.setAttribute("data-forms--validations--counter", id)
+    counter.setAttribute("data-validations--counter", id)
     this.element.insertAdjacentElement("afterend", counter)
     return counter
   }

data/lib/forms/checkbox_group.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Forms
+  # A batched checkbox group for an array-valued field (the tag/facet-picker
+  # shape). Renders a set of checkboxes sharing ONE array-valued field name
+  # (`user[tag_ids][]`), with a leading empty-array hidden field so an empty
+  # selection still submits, and derives each box's checked state from the
+  # resolved value: of its item against the model's current set.
+  #
+  #   f.checkbox_group(:tag_ids, Tag.all, value: :id,
+  #     label: ->(t) { t.name.presence || t.slug }, variant: :pill, size: :sm)
+  #
+  # value:   method or proc -> the submitted value of each item (default :id)
+  # label:   method or proc -> the visible text of each item (default :to_s)
+  # variant: :stack (default) | :inline | :pill — layout only, zero JS
+  # size:    daisyUI checkbox size modifier (:xs :sm :md :lg :xl)
+  #
+  # The checked set is passed in pre-resolved by the builder (Field#checkbox_group
+  # matches the model's current value by each item's resolved value:), so the
+  # component itself stays presentation-only. Each checkbox's markup is delegated
+  # to DaisyUI::Checkbox so its size class is a literal, scanner-visible token.
+  class CheckboxGroup < Phlex::HTML
+    # variant -> the container class. The pill variant uses Tailwind's
+    # `has-[:checked]:` to style the active label with no JS.
+    VARIANT_CLASSES = {
+      stack: "flex flex-col gap-2",
+      inline: "flex flex-wrap gap-4",
+      pill: "flex flex-wrap gap-2"
+    }.freeze
+
+    def initialize(name:, id:, options:, variant: :stack, size: nil, error: false, **attributes)
+      @name = name          # already the array name: "user[tag_ids][]"
+      @id = id
+      @options = options    # [{ value:, label:, checked:, id: }, ...]
+      @variant = variant
+      @size = size
+      @error = error
+      @attributes = attributes
+      super()
+    end
+
+    def view_template
+      # Empty-array hidden field so an empty selection still submits (the same
+      # convention as collection_check_boxes).
+      input(type: "hidden", name: @name, value: "")
+
+      div(class: group_classes, role: "group", "aria-invalid": @error || nil) do
+        @options.each { |option| item(option) }
+      end
+    end
+
+    private
+
+    def item(option)
+      label(class: item_classes) do
+        render_checkbox(option)
+        span(class: item_label_classes) { option[:label].to_s }
+      end
+    end
+
+    # Delegate the checkbox markup to the daisyui gem so the size modifier
+    # resolves to a literal class (checkbox-sm, ...) the CSS scanner can see.
+    def render_checkbox(option)
+      render DaisyUI::Checkbox.new(
+        *checkbox_modifiers,
+        name: @name, id: option[:id], value: option[:value],
+        checked: option[:checked] || nil, class: @attributes[:class]
+      )
+    end
+
+    def checkbox_modifiers = @size ? [@size] : []
+
+    # --- styling seams (the Plain twin overrides these to bare/empty) ---
+
+    def group_classes = VARIANT_CLASSES.fetch(@variant, VARIANT_CLASSES[:stack])
+
+    def item_classes
+      return "label cursor-pointer gap-2 justify-start" unless @variant == :pill
+
+      "badge badge-lg cursor-pointer gap-2 has-[:checked]:badge-primary"
+    end
+
+    def item_label_classes = nil
+  end
+end

data/lib/forms/field.rb

@@ -67,11 +67,15 @@ module Forms
     end
 
     def radio(value, *modifiers, **options)
+      # field_attributes carries value: field_value (the model's CURRENT value).
+      # Drop it here so it can't clobber this radio's own positional value —
+      # otherwise every radio in the group renders the model's value (issue #13).
+      attrs = field_attributes.except(:value).merge(options)
       theme[:radio].new(
         *modifiers,
         value:,
         checked: field_value == value,
-        **field_attributes.merge(options).merge(id: "#{field_id}_#{value}")
+        **attrs.merge(id: "#{field_id}_#{value}")
       )
     end
     alias radio_button radio
@@ -102,6 +106,29 @@ module Forms
       )
     end
 
+    # A model-bound checkbox group over a collection. Shares one array-valued
+    # field name (`scope[name][]`) and derives the checked set from the model's
+    # current value, matched by each item's resolved value: (issue #9).
+    #
+    #   field.checkbox_group(Tag.all, value: :id, label: ->(t) { t.name })
+    #
+    # value:/label: are a method name (Symbol) or a proc taking the item.
+    def checkbox_group(collection, value: :id, label: :to_s, **)
+      # The model's current value is already the raw values (e.g. record.tag_ids
+      # => [1, 3]), so compare against them directly — don't re-resolve value:.
+      selected = Array(field_value)
+      opts = Array(collection).map do |item|
+        item_value = resolve_item(item, value)
+        {
+          value: item_value,
+          label: resolve_item(item, label),
+          checked: selected.include?(item_value),
+          id: "#{field_id}_#{item_value}"
+        }
+      end
+      theme[:checkbox_group].new(name: "#{field_name}[]", id: field_id, options: opts, error: invalid?, **)
+    end
+
     def label(text = nil, *modifiers, **, &block)
       theme[:label].new(*modifiers, text: text || (block ? nil : field_label), for: field_id, **, &block)
     end
@@ -229,6 +256,11 @@ module Forms
       validator.options.key?(:if) || validator.options.key?(:unless) || validator.options.key?(:on)
     end
 
+    # value:/label: for checkbox_group: a Proc taking the item, or a method name.
+    def resolve_item(item, accessor)
+      accessor.respond_to?(:call) ? accessor.call(item) : item.public_send(accessor)
+    end
+
     def field_attributes
       { name: field_name, id: field_id, value: field_value, error: invalid? }
     end

data/lib/forms/form.rb

@@ -104,7 +104,7 @@ module Forms
       attributes_key = nested_attributes ? "#{association_name}_attributes" : association_name.to_s
       base_scope = @scope ? "#{@scope}[#{attributes_key}]" : attributes_key
 
-      if associated.respond_to?(:each_with_index)
+      if collection?(associated)
         associated.each_with_index do |item, index|
           yield build_fields_for("#{base_scope}[#{index}]", item)
         end
@@ -133,6 +133,13 @@ module Forms
       end
     end
 
+    # A batched checkbox group for an array-valued field (issue #9). Delegates to
+    # Field#checkbox_group, which derives the checked set from the model.
+    #   f.checkbox_group(:tag_ids, Tag.all, value: :id, label: :name, variant: :pill)
+    def checkbox_group(name, collection, **)
+      render field_object(name).checkbox_group(collection, **)
+    end
+
     # Rails-style collection_select over an enumerable of records.
     def collection_select(name, collection, value_method, text_method, options = {}, html_options = {})
       choices = collection.map do |item|
@@ -156,6 +163,15 @@ module Forms
 
     private
 
+    # A genuine has_many collection (Array / ActiveRecord::Relation), NOT a
+    # Hash-backed nested scope. A Hash responds to #each_with_index but is a
+    # single nested record (a JSONB column), so iterating it would emit bogus
+    # positional indices — scope[assoc][0][field] — instead of scope[assoc][field]
+    # (issue #10). Enumerable-but-not-Hash covers Relations without requiring AR.
+    def collection?(associated)
+      associated.is_a?(Enumerable) && !associated.is_a?(Hash)
+    end
+
     def build_fields_for(scope, item)
       Forms::FieldsForBuilder.new(
         model: item,
@@ -194,8 +210,16 @@ module Forms
     # UI (novalidate) — the Stimulus layer owns error display.
     def apply_validation_coordinator(attrs)
       existing = attrs[:data][:controller].to_s
-      coordinator = "forms--validations--form"
+      # Derive the coordinator identifier from the introspector's prefix so the
+      # form-level and field-level controllers can never drift (issue #12).
+      coordinator = "#{Forms::Validations::Introspector::CONTROLLER_PREFIX}--form"
       attrs[:data][:controller] = [existing, coordinator].reject(&:empty?).join(" ")
+      # Wire the coordinator's submit handler. Without this data-action the
+      # controller connects but onSubmit never fires, so an invalid form is not
+      # blocked client-side (issue #11). Joined with any caller-supplied action.
+      existing_action = attrs[:data][:action].to_s
+      submit_action = "submit->#{coordinator}#onSubmit"
+      attrs[:data][:action] = [existing_action, submit_action].reject(&:empty?).join(" ")
       attrs[:novalidate] = true
     end
 

data/lib/forms/plain/checkbox_group.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Forms
+  module Plain
+    # Bare checkbox group. Inherits the whole binding contract from
+    # Forms::CheckboxGroup (the shared array name, the empty-array hidden field,
+    # the per-item checked state) and overrides only the rendering seams to ship
+    # zero daisyUI classes. The invalid state rides aria-invalid on the group,
+    # never a color class.
+    class CheckboxGroup < Forms::CheckboxGroup
+      private
+
+      # Bare <input type=checkbox>, no DaisyUI delegation, no styling classes.
+      def render_checkbox(option)
+        input(
+          type: "checkbox", name: @name, id: option[:id],
+          value: option[:value], class: @attributes[:class],
+          checked: option[:checked] || nil
+        )
+      end
+
+      def group_classes = @attributes[:class]
+      def item_classes = nil
+      def item_label_classes = nil
+    end
+  end
+end

data/lib/forms/validations/introspector.rb

@@ -13,7 +13,11 @@ module Forms
     # validation remains authoritative — the client side just
     # shortens the loop for the common cases.
     class Introspector
-      CONTROLLER_PREFIX = "forms--validations"
+      # The Stimulus identifier prefix. Kept in sync with the file path the
+      # controllers ship at (phlex_forms/controllers/validations/*_controller),
+      # so lazyLoadControllersFrom("phlex_forms/controllers") resolves
+      # `validations--length` → .../validations/length_controller (issue #12).
+      CONTROLLER_PREFIX = "validations"
 
       # Validators we know how to mirror. Keys are the short class
       # name (without namespace), values are the controller suffix
@@ -59,9 +63,9 @@ module Forms
 
       # Returns a hash of the shape:
       #   {
-      #     controller: "forms--validations--presence forms--validations--length",
-      #     forms__validations__presence_required_value: "true",
-      #     forms__validations__length_maximum_value: "60",
+      #     controller: "validations--presence validations--length",
+      #     validations__presence_required_value: "true",
+      #     validations__length_maximum_value: "60",
       #   }
       #
       # Returns {} when no supported validators are present.
@@ -95,7 +99,7 @@ module Forms
 
       # Phlex turns underscores in `data:` hash keys into hyphens
       # in the rendered HTML. To produce a key like
-      # `data-forms--validations--length-maximum-value` from a
+      # `data-validations--length-maximum-value` from a
       # Ruby symbol we need every "-" represented as "__" in the
       # symbol. That's what this method builds.
       def data_key(suffix, key)

data/lib/phlex_forms/builder.rb

@@ -165,6 +165,9 @@ module PhlexForms
       when :textarea      then render fo.textarea(*modifiers, required:, **)
       when :toggle        then render fo.toggle(*modifiers, required:, **)
       when :checkbox      then render fo.checkbox(*modifiers, required:, **)
+      # required: doesn't apply to a group of checkboxes sharing one array name;
+      # validate the selection server-side instead.
+      when :checkbox_group then render_checkbox_group(fo, **)
       when :file          then render fo.file(*modifiers, required:, **)
       when :hidden        then render fo.hidden(**)
       when :rich_textarea then render fo.rich_textarea(*modifiers, **)
@@ -177,6 +180,14 @@ module PhlexForms
       end
     end
 
+    # `f.field :tag_ids, as: :checkbox_group, collection: Tag.all, value:, label:`.
+    # collection: names the enumerable; the rest (value:/label:/variant:/size:)
+    # passes through to Field#checkbox_group. (choices:/required: are consumed by
+    # render_field_input's own signature, so they never reach here.)
+    def render_checkbox_group(fo, collection: [], **)
+      render fo.checkbox_group(collection, **)
+    end
+
     def materialize_choices(choices)
       choices.respond_to?(:call) ? choices.call : choices
     end

data/lib/phlex_forms/theme.rb

@@ -55,6 +55,7 @@ module PhlexForms
           input: Forms::Input, select: Forms::Select, choices_select: Forms::ChoicesSelect,
           textarea: Forms::Textarea, rich_textarea: Forms::RichTextarea,
           checkbox: Forms::Checkbox, toggle: Forms::Toggle, radio: Forms::Radio,
+          checkbox_group: Forms::CheckboxGroup,
           file: Forms::FileInput, wrapped_input: Forms::WrappedInput,
           control: Forms::FormControl, label: Forms::Label,
           field_error: Forms::FieldError, field_hint: Forms::FieldHint,
@@ -72,6 +73,7 @@ module PhlexForms
           input: Forms::Plain::Input, select: Forms::Plain::Select, choices_select: Forms::Plain::Select,
           textarea: Forms::Plain::Textarea, rich_textarea: Forms::Plain::Textarea,
           checkbox: Forms::Plain::Checkbox, toggle: Forms::Plain::Checkbox, radio: Forms::Plain::Radio,
+          checkbox_group: Forms::Plain::CheckboxGroup,
           file: Forms::Plain::FileInput, wrapped_input: Forms::Plain::WrappedInput,
           control: Forms::Plain::Control, label: Forms::Plain::Label,
           field_error: Forms::Plain::FieldError, field_hint: Forms::Plain::FieldHint,

data/lib/phlex_forms/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PhlexForms
-  VERSION = "0.2.3"
+  VERSION = "0.2.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-forms
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.4
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -114,6 +114,7 @@ files:
 - config/rubocop.yml
 - lib/forms/base.rb
 - lib/forms/checkbox.rb
+- lib/forms/checkbox_group.rb
 - lib/forms/choices_select.rb
 - lib/forms/collection_check_box.rb
 - lib/forms/collection_check_box_builder.rb
@@ -133,6 +134,7 @@ files:
 - lib/forms/live/field.rb
 - lib/forms/password_field.rb
 - lib/forms/plain/checkbox.rb
+- lib/forms/plain/checkbox_group.rb
 - lib/forms/plain/control.rb
 - lib/forms/plain/field_error.rb
 - lib/forms/plain/field_hint.rb