superform 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5525e912faf72d0525d0aa35d7ec2ef22ced3a4e8b8cf7d99483850f4bfe5074
-  data.tar.gz: f0dfde4e0c1ec94e036addce561fee83039627e65236872922525b361abb34d2
+  metadata.gz: b9c458186315ee97fe98e0b3c304ca674967ee6e2c9f797aadec175a629fa3ef
+  data.tar.gz: 65a76515d2f07965a9c5beff64861ef1ea02b46f6ee498304cf665a36990ecb9
 SHA512:
-  metadata.gz: a513255c99aee3da7992521e0d56db5ac14a7cb1d5ed52ad918124a3722b07adcab9490a35587f5c0386659e8173404e58d541d1cb7a277634c9d2929955bbb9
-  data.tar.gz: df12f03bb89cd6d76c058ad8100ef9b75bf6dce91dc6c0f146bbddf596502e659279b7c58ff2a9db6641fa12d1ac8eaace4e1096dc604b956501b9e6960d83b7
+  metadata.gz: 9150a51203dd7bc4ca7dcdd3b629cde2c5b0eaf37446c0ffd9a9697201de0af24b041c57c3e4ecf268d6f40f1c9f424760b058bcd31480d4af515f9e39d07de9
+  data.tar.gz: 45c5794a688e16daa4818068136163bfa68ae86ba61e1797960c8d2eff3d8cb88d5cbd69752569163ffc183a75e944ddcade6cabf49a3992734457b94752b70d

data/Gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: .
   specs:
-    superform (0.5.0)
-      phlex-rails (~> 1.0)
+    superform (0.5.1)
+      phlex-rails (>= 1.0, < 3.0)
       zeitwerk (~> 2.6)
 
 GEM
@@ -46,8 +46,8 @@ GEM
     diff-lcs (1.5.1)
     drb (2.2.1)
     erubi (1.13.0)
-    ffi (1.17.0-arm64-darwin)
-    ffi (1.17.0-x86_64-linux-gnu)
+    ffi (1.17.1-arm64-darwin)
+    ffi (1.17.1-x86_64-linux-gnu)
     formatador (1.1.0)
     guard (2.18.1)
       formatador (>= 0.2.4)
@@ -80,9 +80,9 @@ GEM
     method_source (1.1.0)
     minitest (5.25.1)
     nenv (0.3.0)
-    nokogiri (1.16.7-arm64-darwin)
+    nokogiri (1.18.3-arm64-darwin)
       racc (~> 1.4)
-    nokogiri (1.16.7-x86_64-linux)
+    nokogiri (1.18.3-x86_64-linux-gnu)
       racc (~> 1.4)
     notiffany (0.1.3)
       nenv (~> 0.1)
@@ -154,6 +154,7 @@ GEM
 PLATFORMS
   arm64-darwin-22
   arm64-darwin-23
+  arm64-darwin-24
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -33,10 +33,10 @@ After installing, create a form in `app/views/*/form.rb`. For example, a form fo
 ```ruby
 # ./app/views/posts/form.rb
 class Posts::Form < ApplicationForm
-  def template(&)
-    row field(:title).input
-    row field(:body).textarea
-    row field(:blog).select Blog.select(:id, :title)
+  def view_template(&)
+    labeled field(:title).input
+    labeled field(:body).textarea
+    labeled field(:blog).select Blog.select(:id, :title)
   end
 end
 ```
@@ -56,19 +56,22 @@ Superforms are built out of [Phlex components](https://www.phlex.fun/html/compon
 # ./app/views/forms/application_form.rb
 class ApplicationForm < Superform::Rails::Form
   class MyInputComponent < Superform::Rails::Components::InputComponent
-    def template(&)
+    def view_template(&)
       div class: "form-field" do
         input(**attributes)
       end
     end
   end
 
+  # Redefining the base Field class lets us override every field component.
   class Field < Superform::Rails::Form::Field
     def input(**attributes)
       MyInputComponent.new(self, attributes: attributes)
     end
   end
 
+  # Here we make a simple helper to make our syntax shorter. Given a field it
+  # will also render its label.
   def labeled(component)
     div class: "form-row" do
       render component.field.label
@@ -87,7 +90,7 @@ That looks like a LOT of code, and it is, but look at how easy it is to create f
 ```ruby
 # ./app/views/users/form.rb
 class Users::Form < ApplicationForm
-  def template(&)
+  def view_template(&)
     labeled field(:name).input
     labeled field(:email).input(type: :email)
 
@@ -112,7 +115,7 @@ Consider a form for an account that lets people edit the names and email of the
 
 ```ruby
 class AccountForm < Superform::Rails::Form
-  def template
+  def view_template
     # Account#owner returns a single object
     namespace :owner do |owner|
       # Renders input with the name `account[owner][name]`
@@ -161,7 +164,7 @@ By default Superform namespaces a form based on the ActiveModel model name param
 
 ```ruby
 class UserForm < Superform::Rails::Form
-  def template
+  def view_template
     render field(:email).input
   end
 end
@@ -177,7 +180,7 @@ To customize the form namespace, like an ActiveRecord model nested within a modu
 
 ```ruby
 class UserForm < Superform::Rails::Form
-  def template
+  def view_template
     render field(:email).input
   end
   
@@ -202,7 +205,7 @@ In practice, many of the calls below you'd put inside of a method. This cuts dow
 ```ruby
 # Everything below is intentionally verbose!
 class SignupForm < ApplicationForm
-  def template
+  def view_template
     # The most basic type of input, which will be autofocused.
     render field(:name).input.focus
 
@@ -210,10 +213,10 @@ class SignupForm < ApplicationForm
     render field(:email).input(type: :email, placeholder: "We will sell this to third parties", required: true)
 
     # You can put fields in a block if that's your thing.
-    render field(:reason) do |f|
+    field(:reason) do |f|
       div do
-        f.label { "Why should we care about you?" }
-        f.textarea(row: 3, col: 80)
+        render f.label { "Why should we care about you?" }
+        render f.textarea(row: 3, col: 80)
       end
     end
 
@@ -231,6 +234,8 @@ class SignupForm < ApplicationForm
     div do
       render field(:source).label { "How did you hear about us?" }
       render field(:source).select do |s|
+        # Renders a blank option.
+        s.blank_option
         # Pretend WebSources is an ActiveRecord scope with a "Social" category that has "Facebook, X, etc"
         # and a "Search" category with "AltaVista, Yahoo, etc."
         WebSources.select(:id, :name).group_by(:category) do |category, sources|
@@ -256,7 +261,7 @@ If you want to add file upload fields to your form you will need to initialize y
 
 ```ruby
 class User::ImageForm < ApplicationForm
-  def template
+  def view_template
     # render label
     render field(:image).label { "Choose file" }
     # render file input with accept attribute for png and jpeg images
@@ -277,7 +282,7 @@ The best part? If you have forms with a completely different look and feel, you
 ```ruby
 class AdminForm < ApplicationForm
   class AdminInput < ApplicationComponent
-    def template(&)
+    def view_template(&)
       input(**attributes)
       small { admin_tool_tip_for field.key }
     end
@@ -295,7 +300,7 @@ Then, just like you did in your Erb, you create the form:
 
 ```ruby
 class Admin::Users::Form < AdminForm
-  def template(&)
+  def view_template(&)
     labeled field(:name).tooltip_input
     labeled field(:email).tooltip_input(type: :email)
 

data/lib/superform/dom.rb

@@ -0,0 +1,51 @@
+module Superform
+  # Generates DOM IDs, names, etc. for a Field, Namespace, or Node based on
+  # 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
+    def initialize(field:)
+      @field = field
+    end
+
+    # Converts the value of the field to a String, which is required to work
+    # with Phlex. Assumes that `Object#to_s` emits a format suitable for the web form.
+    def value
+      @field.value.to_s
+    end
+
+    # 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
+      lineage.map(&:key).join("_")
+    end
+
+    # The `name` attribute of a node, which is influenced by Rails (not sure where Rails got
+    # it from). All node names, except the parent node, are wrapped in a `[]` and collections
+    # are left empty. For example, `user[addresses][][street]` would be created for a form with
+    # data shaped like `{user: {addresses: [{street: "Sesame Street"}]}}`.
+    def name
+      root, *names = keys
+      names.map { |name| "[#{name}]" }.unshift(root).join
+    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}/>"
+    end
+
+    private
+
+    def keys
+      lineage.map do |node|
+        # If the parent of a field is a field, the name should be nil.
+        node.key unless node.parent.is_a? Field
+      end
+    end
+
+    # One-liner way of walking from the current node all the way up to the parent.
+    def lineage
+      Enumerator.produce(@field, &:parent).take_while(&:itself).reverse
+    end
+  end
+end

data/lib/superform/field.rb

@@ -0,0 +1,39 @@
+module Superform
+  # A Field represents the data associated with a form element. This class provides
+  # methods for accessing and modifying the field's value. HTML concerns are all
+  # delegated to the DOM object.
+  class Field < Node
+    attr_reader :dom
+
+    def initialize(key, parent:, object: nil, value: nil)
+      super key, parent: parent
+      @object = object
+      @value = value
+      @dom = Superform::DOM.new(field: self)
+    end
+
+    def value
+      if @object and @object.respond_to? @key
+        @object.send @key
+      else
+        @value
+      end
+    end
+    alias :serialize :value
+
+    def assign(value)
+      if @object and @object.respond_to? "#{@key}="
+        @object.send "#{@key}=", value
+      else
+        @value = value
+      end
+    end
+    alias :value= :assign
+
+    # Wraps a field that's an array of values with a bunch of fields
+    # that are indexed with the array's index.
+    def collection(&)
+      @collection ||= FieldCollection.new(field: self, &)
+    end
+  end
+end

data/lib/superform/field_collection.rb

@@ -0,0 +1,33 @@
+module Superform
+  # A FieldCollection represents values that are collections of literals. For example, a Note
+  # ActiveRecord object might have a collection of tags that's an array of string literals.
+  class FieldCollection
+    include Enumerable
+
+    def initialize(field:, &)
+      @field = field
+      @index = 0
+      each(&) if block_given?
+    end
+
+    def each(&)
+      values.each do |value|
+        yield build_field(value: value)
+      end
+    end
+
+    def field
+      build_field
+    end
+
+    def values
+      Array(@field.value)
+    end
+
+    private
+
+    def build_field(**)
+      @field.class.new(@index += 1, parent: @field, **)
+    end
+  end
+end

data/lib/superform/namespace.rb

@@ -0,0 +1,124 @@
+module Superform
+  # A Namespace maps and object to values, but doesn't actually have a value itself. For
+  # example, a `User` object or ActiveRecord model could be passed into the `:user` namespace.
+  # To access the values on a Namespace, the `field` can be called for single values.
+  #
+  # Additionally, to access namespaces within a namespace, such as if a `User has_many :addresses` in
+  # ActiveRecord, the `namespace` method can be called which will return another Namespace object and
+  # set the current Namespace as the parent.
+  class Namespace < Node
+    include Enumerable
+
+    attr_reader :object
+
+    def initialize(key, parent:, object: nil, field_class: Field)
+      super(key, parent: parent)
+      @object = object
+      @field_class = field_class
+      @children = Hash.new
+      yield self if block_given?
+    end
+
+    # Creates a `Namespace` child instance with the parent set to the current instance, adds to
+    # the `@children` Hash to ensure duplicate child namespaces aren't created, then calls the
+    # method on the `@object` to get the child object to pass into that namespace.
+    #
+    # For example, if a `User#permission` returns a `Permission` object, we could map that to a
+    # form like this:
+    #
+    # ```ruby
+    # Superform :user, object: User.new do |form|
+    #   form.namespace :permission do |permission|
+    #     form.field :role
+    #   end
+    # end
+    # ```
+    def namespace(key, &block)
+      create_child(key, self.class, object: object_for(key: key), &block)
+    end
+
+    # Maps the `Object#proprety` and `Object#property=` to a field in a web form that can be
+    # read and set by the form. For example, a User form might look like this:
+    #
+    # ```ruby
+    # Superform :user, object: User.new do |form|
+    #   form.field :email
+    #   form.field :name
+    # end
+    # ```
+    def field(key)
+      create_child(key, @field_class, object: object).tap do |field|
+        yield field if block_given?
+      end
+    end
+
+    # Wraps an array of objects in Namespace classes. For example, if `User#addresses` returns
+    # an enumerable or array of `Address` classes:
+    #
+    # ```ruby
+    # Superform :user, object: User.new do |form|
+    #   form.field :email
+    #   form.field :name
+    #   form.collection :addresses do |address|
+    #     address.field(:street)
+    #     address.field(:state)
+    #     address.field(:zip)
+    #   end
+    # end
+    # ```
+    # The object within the block is a `Namespace` object that maps each object within the enumerable
+    # to another `Namespace` or `Field`.
+    def collection(key, &)
+      create_child(key, NamespaceCollection, &)
+    end
+
+    # Creates a Hash of Hashes and Arrays that represent the fields and collections of the Superform.
+    # This can be used to safely update ActiveRecord objects without the need for Strong Parameters.
+    # You will want to make sure that all the fields displayed in the form are ones that you're OK updating
+    # from the generated hash.
+    def serialize
+      each_with_object Hash.new do |child, hash|
+        hash[child.key] = child.serialize
+      end
+    end
+
+    # Iterates through the children of the current namespace, which could be `Namespace` or `Field`
+    # objects.
+    def each(&)
+      @children.values.each(&)
+    end
+
+    # Assigns a hash to the current namespace and children namespace.
+    def assign(hash)
+      each do |child|
+        child.assign hash[child.key]
+      end
+      self
+    end
+
+    # Creates a root Namespace, which is essentially a form.
+    def self.root(*, **, &)
+      new(*, parent: nil, **, &)
+    end
+
+    protected
+
+    # Calls the corresponding method on the object for the `key` name, if it exists. For example
+    # if the `key` is `email` on `User`, this method would call `User#email` if the method is
+    # present.
+    #
+    # This method could be overwritten if the mapping between the `@object` and `key` name is not
+    # a method call. For example, a `Hash` would be accessed via `user[:email]` instead of `user.send(:email)`
+    def object_for(key:)
+      @object.send(key) if @object.respond_to? key
+    end
+
+    private
+
+    # Checks if the child exists. If it does then it returns that. If it doesn't, it will
+    # build the child.
+    def create_child(key, child_class, **kwargs, &block)
+      @children.fetch(key) { @children[key] = child_class.new(key, parent: self, **kwargs, &block) }
+    end
+  end
+end

data/lib/superform/namespace_collection.rb

@@ -0,0 +1,48 @@
+module Superform
+  # A NamespaceCollection represents values that are collections of namespaces. For example, a User
+  # ActiveRecord object might have many Addresses. Each individual address is then delegated out
+  # to a Namespace object.
+  class NamespaceCollection < Node
+    include Enumerable
+
+    def initialize(key, parent:, &template)
+      super(key, parent: parent)
+      @template = template
+      @namespaces = enumerate(parent_collection)
+    end
+
+    def serialize
+      map(&:serialize)
+    end
+
+    def assign(array)
+      # The problem with zip-ing the array is if I need to add new
+      # elements to it and wrap it in the namespace.
+      zip(array) do |namespace, hash|
+        namespace.assign hash
+      end
+    end
+
+    def each(&)
+      @namespaces.each(&)
+    end
+
+    private
+
+    def enumerate(enumerator)
+      Enumerator.new do |y|
+        enumerator.each.with_index do |object, key|
+          y << build_namespace(key, object: object)
+        end
+      end
+    end
+
+    def build_namespace(index, **)
+      parent.class.new(index, parent: self, **, &@template)
+    end
+
+    def parent_collection
+      @parent.object.send @key
+    end
+  end
+end

data/lib/superform/node.rb

@@ -0,0 +1,12 @@
+module Superform
+  # Superclass for Namespace and Field classes. Not much to it other than it has a `name`
+  # and `parent` node attribute. Think of it as a tree.
+  class Node
+    attr_reader :key, :parent
+
+    def initialize(key, parent:)
+      @key = key
+      @parent = parent
+    end
+  end
+end

data/lib/superform/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Superform
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/lib/superform.rb

@@ -3,304 +3,13 @@ require "zeitwerk"
 module Superform
   Loader = Zeitwerk::Loader.for_gem.tap do |loader|
     loader.ignore "#{__dir__}/generators"
+    loader.inflector.inflect(
+      'dom' => 'DOM'
+    )
     loader.setup
   end
 
   class Error < StandardError; end
-
-  # Generates DOM IDs, names, etc. for a Field, Namespace, or Node based on
-  # 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
-    def initialize(field:)
-      @field = field
-    end
-
-    # Converts the value of the field to a String, which is required to work
-    # with Phlex. Assumes that `Object#to_s` emits a format suitable for the web form.
-    def value
-      @field.value.to_s
-    end
-
-    # 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
-      lineage.map(&:key).join("_")
-    end
-
-    # The `name` attribute of a node, which is influenced by Rails (not sure where Rails got
-    # it from). All node names, except the parent node, are wrapped in a `[]` and collections
-    # are left empty. For example, `user[addresses][][street]` would be created for a form with
-    # data shaped like `{user: {addresses: [{street: "Sesame Street"}]}}`.
-    def name
-      root, *names = keys
-      names.map { |name| "[#{name}]" }.unshift(root).join
-    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}/>"
-    end
-
-    private
-
-    def keys
-      lineage.map do |node|
-        # If the parent of a field is a field, the name should be nil.
-        node.key unless node.parent.is_a? Field
-      end
-    end
-
-    # One-liner way of walking from the current node all the way up to the parent.
-    def lineage
-      Enumerator.produce(@field, &:parent).take_while(&:itself).reverse
-    end
-  end
-
-
-  # Superclass for Namespace and Field classes. Not much to it other than it has a `name`
-  # and `parent` node attribute. Think of it as a tree.
-  class Node
-    attr_reader :key, :parent
-
-    def initialize(key, parent:)
-      @key = key
-      @parent = parent
-    end
-  end
-
-  # A Namespace maps and object to values, but doesn't actually have a value itself. For
-  # example, a `User` object or ActiveRecord model could be passed into the `:user` namespace.
-  # To access the values on a Namespace, the `field` can be called for single values.
-  #
-  # Additionally, to access namespaces within a namespace, such as if a `User has_many :addresses` in
-  # ActiveRecord, the `namespace` method can be called which will return another Namespace object and
-  # set the current Namespace as the parent.
-  class Namespace < Node
-    include Enumerable
-
-    attr_reader :object
-
-    def initialize(key, parent:, object: nil, field_class: Field)
-      super(key, parent: parent)
-      @object = object
-      @field_class = field_class
-      @children = Hash.new
-      yield self if block_given?
-    end
-
-    # Creates a `Namespace` child instance with the parent set to the current instance, adds to
-    # the `@children` Hash to ensure duplicate child namespaces aren't created, then calls the
-    # method on the `@object` to get the child object to pass into that namespace.
-    #
-    # For example, if a `User#permission` returns a `Permission` object, we could map that to a
-    # form like this:
-    #
-    # ```ruby
-    # Superform :user, object: User.new do |form|
-    #   form.namespace :permission do |permission|
-    #     form.field :role
-    #   end
-    # end
-    # ```
-    def namespace(key, &block)
-      create_child(key, self.class, object: object_for(key: key), &block)
-    end
-
-    # Maps the `Object#proprety` and `Object#property=` to a field in a web form that can be
-    # read and set by the form. For example, a User form might look like this:
-    #
-    # ```ruby
-    # Superform :user, object: User.new do |form|
-    #   form.field :email
-    #   form.field :name
-    # end
-    # ```
-    def field(key)
-      create_child(key, @field_class, object: object).tap do |field|
-        yield field if block_given?
-      end
-    end
-
-    # Wraps an array of objects in Namespace classes. For example, if `User#addresses` returns
-    # an enumerable or array of `Address` classes:
-    #
-    # ```ruby
-    # Superform :user, object: User.new do |form|
-    #   form.field :email
-    #   form.field :name
-    #   form.collection :addresses do |address|
-    #     address.field(:street)
-    #     address.field(:state)
-    #     address.field(:zip)
-    #   end
-    # end
-    # ```
-    # The object within the block is a `Namespace` object that maps each object within the enumerable
-    # to another `Namespace` or `Field`.
-    def collection(key, &)
-      create_child(key, NamespaceCollection, &)
-    end
-
-    # Creates a Hash of Hashes and Arrays that represent the fields and collections of the Superform.
-    # This can be used to safely update ActiveRecord objects without the need for Strong Parameters.
-    # You will want to make sure that all the fields displayed in the form are ones that you're OK updating
-    # from the generated hash.
-    def serialize
-      each_with_object Hash.new do |child, hash|
-        hash[child.key] = child.serialize
-      end
-    end
-
-    # Iterates through the children of the current namespace, which could be `Namespace` or `Field`
-    # objects.
-    def each(&)
-      @children.values.each(&)
-    end
-
-    # Assigns a hash to the current namespace and children namespace.
-    def assign(hash)
-      each do |child|
-        child.assign hash[child.key]
-      end
-      self
-    end
-
-    # Creates a root Namespace, which is essentially a form.
-    def self.root(*, **, &)
-      new(*, parent: nil, **, &)
-    end
-
-    protected
-
-    # Calls the corresponding method on the object for the `key` name, if it exists. For example
-    # if the `key` is `email` on `User`, this method would call `User#email` if the method is
-    # present.
-    #
-    # This method could be overwritten if the mapping between the `@object` and `key` name is not
-    # a method call. For example, a `Hash` would be accessed via `user[:email]` instead of `user.send(:email)`
-    def object_for(key:)
-      @object.send(key) if @object.respond_to? key
-    end
-
-    private
-
-    # Checks if the child exists. If it does then it returns that. If it doesn't, it will
-    # build the child.
-    def create_child(key, child_class, **kwargs, &block)
-      @children.fetch(key) { @children[key] = child_class.new(key, parent: self, **kwargs, &block) }
-    end
-  end
-
-  class Field < Node
-    attr_reader :dom
-
-    def initialize(key, parent:, object: nil, value: nil)
-      super key, parent: parent
-      @object = object
-      @value = value
-      @dom = DOM.new(field: self)
-    end
-
-    def value
-      if @object and @object.respond_to? @key
-        @object.send @key
-      else
-        @value
-      end
-    end
-    alias :serialize :value
-
-    def assign(value)
-      if @object and @object.respond_to? "#{@key}="
-        @object.send "#{@key}=", value
-      else
-        @value = value
-      end
-    end
-    alias :value= :assign
-
-    # Wraps a field that's an array of values with a bunch of fields
-    # that are indexed with the array's index.
-    def collection(&)
-      @collection ||= FieldCollection.new(field: self, &)
-    end
-  end
-
-  class FieldCollection
-    include Enumerable
-
-    def initialize(field:, &)
-      @field = field
-      @index = 0
-      each(&) if block_given?
-    end
-
-    def each(&)
-      values.each do |value|
-        yield build_field(value: value)
-      end
-    end
-
-    def field
-      build_field
-    end
-
-    def values
-      Array(@field.value)
-    end
-
-    private
-
-    def build_field(**)
-      @field.class.new(@index += 1, parent: @field, **)
-    end
-  end
-
-  class NamespaceCollection < Node
-    include Enumerable
-
-    def initialize(key, parent:, &template)
-      super(key, parent: parent)
-      @template = template
-      @namespaces = enumerate(parent_collection)
-    end
-
-    def serialize
-      map(&:serialize)
-    end
-
-    def assign(array)
-      # The problem with zip-ing the array is if I need to add new
-      # elements to it and wrap it in the namespace.
-      zip(array) do |namespace, hash|
-        namespace.assign hash
-      end
-    end
-
-    def each(&)
-      @namespaces.each(&)
-    end
-
-    private
-
-    def enumerate(enumerator)
-      Enumerator.new do |y|
-        enumerator.each.with_index do |object, key|
-          y << build_namespace(key, object: object)
-        end
-      end
-    end
-
-    def build_namespace(index, **)
-      parent.class.new(index, parent: self, **, &@template)
-    end
-
-    def parent_collection
-      @parent.object.send @key
-    end
-  end
 end
 
 def Superform(...)

metadata

@@ -1,29 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: superform
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Brad Gessler
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-10-15 00:00:00.000000000 Z
+date: 2025-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: phlex-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -58,6 +63,12 @@ files:
 - lib/generators/superform/install/install_generator.rb
 - lib/generators/superform/install/templates/application_form.rb
 - lib/superform.rb
+- lib/superform/dom.rb
+- lib/superform/field.rb
+- lib/superform/field_collection.rb
+- lib/superform/namespace.rb
+- lib/superform/namespace_collection.rb
+- lib/superform/node.rb
 - lib/superform/rails.rb
 - lib/superform/version.rb
 - sig/superform.rbs
@@ -69,7 +80,6 @@ metadata:
   homepage_uri: https://github.com/rubymonolith/superform
   source_code_uri: https://github.com/rubymonolith/superform
   changelog_uri: https://github.com/rubymonolith/superform
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -84,8 +94,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Build forms in Rails
 test_files: []