superform 0.6.1 → 0.7.0

data/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
@@ -17,7 +23,7 @@ module Superform
     # 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
-      lineage.map(&:key).join("_")
+      self.class.join(*lineage.map(&:key))
     end
 
     # The `name` attribute of a node, which is influenced by Rails (not sure where Rails got
@@ -29,6 +35,12 @@ module Superform
       names.map { |name| "[#{name}]" }.unshift(root).join
     end
 
+    # Returns the name with `[]` appended for array/multiple value fields.
+    # Used by multiple selects, checkbox groups, etc.
+    def array_name
+      "#{name}[]"
+    end
+
     # Emit the id, name, and value in an HTML tag-ish that doesnt have an element.
     def inspect
       "<id=#{id.inspect} name=#{name.inspect} value=#{value.inspect}/>"

data/lib/superform/field.rb

@@ -3,7 +3,12 @@ module Superform
   # methods for accessing and modifying the field's value. HTML concerns are all
   # delegated to the DOM object.
   class Field < Node
-    attr_reader :dom
+    # Helpful for overriding methods in the `input`, `email`, `label`, etc. calls.
+    include Phlex::Helpers
+
+    # Expose these as a reader so they're accessible from the `input`, `label`,
+    # etc. methods.
+    attr_reader :dom, :object
 
     def initialize(key, parent:, object: nil, value: nil)
       super key, parent: parent
@@ -42,28 +47,6 @@ module Superform
       self
     end
 
-    # A helper, borrowed from Phlex, that makes it easy to "grab" values
-    # passed into a method that are reserved keywords. For example, this
-    # would throw a syntax error because `class` and `end` are reserved:
-    #
-    # def foo(end:, class:)
-    #   puts class
-    #   puts end
-    # end
-    #
-    # So you "grab" them like this:
-    # def foo(end:, class:)
-    #   puts grab(end:)
-    #   puts grab(class:)
-    # end
-    private def grab(**bindings)
-      if bindings.size > 1
-       	bindings.values
-      else
-     	  bindings.values.first
-      end
-    end
-
     # High-performance Kit proxy that wraps field methods with form.render calls.
     # Uses Ruby class hooks to define methods at the class level for maximum speed:
     # - Methods are defined once per Field class, not per Kit instance
@@ -85,7 +68,7 @@ module Superform
       # Create a new Kit class for each Field subclass with true isolation
       # Copy methods from parent Field classes at creation time, not through inheritance
       subclass.const_set(:Kit, Class.new(Field::Kit))
-      
+
       # Copy all existing methods from the inheritance chain
       field_class = self
       while field_class != Field
@@ -99,7 +82,7 @@ module Superform
       # Skip if this is the base Field class or if we don't have a Kit class yet
       return if self == Field
       return unless const_defined?(:Kit, false)
-      
+
       # Only add method to THIS class's Kit, not subclasses (isolation)
       add_method_to_kit(method_name, self::Kit)
     end
@@ -111,14 +94,14 @@ module Superform
     private
 
     def self.copy_field_methods_to_kit(field_class, kit_class)
-      base_methods = (Object.instance_methods + Node.instance_methods + 
+      base_methods = (Object.instance_methods + Node.instance_methods +
                      [: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?('=')
         next if base_methods.include?(method_name)
         next if kit_class.method_defined?(method_name)
-        
+
         kit_class.define_method(method_name) do |*args, **kwargs, &block|
           result = @field.send(method_name, *args, **kwargs, &block)
           @form.render result
@@ -128,12 +111,12 @@ module Superform
 
     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 + 
+
+      base_methods = (Object.instance_methods + Node.instance_methods +
                      [:dom, :value, :serialize, :assign, :collection, :field, :kit]).to_set
       return if base_methods.include?(method_name)
       return if kit_class.method_defined?(method_name)
-      
+
       kit_class.define_method(method_name) do |*args, **kwargs, &block|
         result = @field.send(method_name, *args, **kwargs, &block)
         @form.render result

data/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

data/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

data/lib/superform/rails/choices.rb

@@ -0,0 +1,6 @@
+module Superform
+  module Rails
+    module Choices
+    end
+  end
+end

data/lib/superform/rails/components/base.rb

@@ -6,9 +6,16 @@ module Superform
 
         delegate :dom, to: :field
 
-        def initialize(field, attributes: {})
+        def initialize(field, attributes: nil, **attributes_kwargs)
           @field = field
-          @attributes = attributes
+          if attributes
+            warn "[DEPRECATION] Passing `attributes:` keyword to #{self.class.name} is deprecated. " \
+                 "Pass HTML attributes as keyword arguments directly instead: " \
+                 "#{self.class.name}.new(field, **attributes)"
+            @attributes = attributes.merge(attributes_kwargs)
+          else
+            @attributes = attributes_kwargs
+          end
         end
 
         def field_attributes

data/lib/superform/rails/components/checkbox.rb

@@ -2,18 +2,45 @@ module Superform
   module Rails
     module Components
       class Checkbox < Field
+        def initialize(field, index: nil, **attributes)
+          super(field, **attributes)
+          @index = index
+        end
+
         def view_template(&)
-          # Rails has a hidden and checkbox input to deal with sending back a value
-          # to the server regardless of if the input is checked or not.
-          input(name: dom.name, type: :hidden, value: "0")
-          # The hard coded keys need to be in here so the user can't overrite them.
-          input(type: :checkbox, value: "1", **attributes)
+          if boolean?
+            # Rails convention: hidden input ensures a value is sent even when unchecked
+            input(name: dom.name, type: :hidden, value: "0")
+            input(type: :checkbox, value: "1", **attributes)
+          elsif collection?
+            input(type: :checkbox, value: dom.value, **attributes)
+          else
+            input(type: :checkbox, **attributes)
+          end
         end
 
         def field_attributes
-          { id: dom.id, name: dom.name, checked: field.value }
+          if boolean?
+            { id: dom.id, name: dom.name, checked: field.value }
+          elsif collection?
+            { id: dom.id, name: dom.name, checked: true }
+          else
+            { id: DOM.join(dom.id, @index || @attributes[:value]), name: dom.array_name, checked: Array(field.value).include?(@attributes[:value]) }
+          end
+        end
+
+        private
+
+        # Inside a FieldCollection — the field is a child of another Field
+        def collection?
+          field.parent.is_a?(Superform::Field)
+        end
+
+        # Scalar field with no explicit value — classic on/off toggle
+        def boolean?
+          !collection? && !field.value.is_a?(Array)
         end
       end
     end
   end
-end
+end

data/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

data/lib/superform/rails/components/datalist.rb

@@ -0,0 +1,34 @@
+module Superform
+  module Rails
+    module Components
+      class Datalist < Field
+        def initialize(field, options: [], **attributes)
+          super(field, **attributes)
+          @options = options
+        end
+
+        def view_template(&block)
+          datalist_id = DOM.join(dom.id, "datalist")
+          input(list: datalist_id, **attributes)
+          datalist(id: datalist_id) do
+            if block
+              yield self
+            else
+              options(*@options)
+            end
+          end
+        end
+
+        def options(*collection)
+          Choices::Mapper.new(collection).each do |value, text|
+            if value == text
+              option(value: value)
+            else
+              option(value: value) { text }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/superform/rails/components/input.rb

@@ -2,7 +2,7 @@ module Superform
   module Rails
     module Components
       class Input < Field
-        def view_template(&)
+        def view_template
           input(**attributes)
         end
 

data/lib/superform/rails/components/label.rb

@@ -12,7 +12,7 @@ module Superform
         end
 
         def label_text
-          field.key.to_s.titleize
+          field.human_attribute_name
         end
       end
     end

data/lib/superform/rails/components/radio.rb

@@ -0,0 +1,21 @@
+module Superform
+  module Rails
+    module Components
+      class Radio < Field
+        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.join(dom.id, @index), name: dom.name, value: @value, checked: field.value == @value }
+        end
+      end
+    end
+  end
+end

data/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

data/lib/superform/rails/components/select.rb

@@ -2,22 +2,54 @@ module Superform
   module Rails
     module Components
       class Select < Field
-        def initialize(*, collection: [], **, &)
-          super(*, **, &)
-          @collection = collection
+        def initialize(
+          field,
+          options: [],
+          collection: nil,
+          multiple: false,
+          **attributes,
+          &
+        )
+          super(field, **attributes, &)
+
+          # Handle deprecated collection parameter
+          if collection && options.empty?
+            warn "[DEPRECATION] Superform::Rails::Components::Select: " \
+                 "`collection:` keyword is deprecated and will be removed. " \
+                 "Use positional arguments instead: field.select([1, 'A'], [2, 'B'])"
+            options = collection
+          end
+
+          @options = options
+          @multiple = multiple
         end
 
-        def view_template(&options)
+        def view_template(&block)
+          # Hidden input ensures a value is sent even when all options are
+          # deselected in a multiple select
+          if @multiple
+            hidden_name = field.parent.is_a?(Superform::Field) ? dom.name : dom.array_name
+            input(type: "hidden", name: hidden_name, value: "")
+          end
+
           if block_given?
-            select(**attributes, &options)
+            select(**attributes, &block)
           else
-            select(**attributes) { options(*@collection) }
+            select(**attributes) do
+              options(*@options)
+            end
           end
         end
 
         def options(*collection)
+          # Handle both single values and arrays (for multiple selects)
+          selected_values = Array(field.value)
           map_options(collection).each do |key, value|
-            option(selected: field.value == key, value: key) { value }
+            if key.nil?
+              blank_option
+            else
+              option(selected: selected_values.include?(key), value: key) { value }
+            end
           end
         end
 
@@ -35,7 +67,19 @@ module Superform
 
         protected
           def map_options(collection)
-            OptionMapper.new(collection)
+            Choices::Mapper.new(collection)
+          end
+
+          def field_attributes
+            attrs = super
+            if @multiple
+              # Only append [] if the field doesn't already have a Field parent
+              # (which would mean it's already in a collection and has [] notation)
+              name = field.parent.is_a?(Superform::Field) ? attrs[:name] : dom.array_name
+              attrs.merge(multiple: true, name: name)
+            else
+              attrs
+            end
           end
       end
     end