pxs-forms 0.0.15 → 0.0.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14b39bac9452c6f1c71de938ea6ef066dba69a0d861048f7f8c691af49b51ee6
-  data.tar.gz: 1a96903d410a21e147dc3fcdfa00752178c7e45ae6dd2f3b3c3215a60069f18d
+  metadata.gz: c840e8cf5cad383cbd45ad80f54f696798d55eda8d6ffa805f30d9fe7ad08763
+  data.tar.gz: 94155c2dbfc0598169bde41a3d3af2cf0360fb3b3370a0cd981224b3fb05f903
 SHA512:
-  metadata.gz: 638a4ed2810a3e316043aad98a4720cde8317645171694ef026081e0fabe93588541236a35dd3f6854013bb79a9a45df29f060ed907ee821c9629c0906253553
-  data.tar.gz: ba16db0647f94210668ccf504bfa0c763ff62225be35cf431710f6466629ecd89d16fee5fe99387a8bacf188fa373c01fd88fe6792d5cdecd8a1dc0992f07eaf
+  metadata.gz: 6d7c6d96598f06fab708c128932378bec6930d6b28e9acd4e04b7c12410a0177610511389a41e7e0025dbecd2c6a1c7286bef6ca061c549cd9037c371d21aa40
+  data.tar.gz: 04301a70b9b5d953998592eb281d06442280f28c5a675df9887caeed51c40852a251a60d136805b74bac49cfad20891bce061955202e1585b930ef79a0044e77

data/CHANGELOG.md

@@ -6,4 +6,14 @@
 
 ## [0.0.11] - 2024-04-19
 
-- Added currency field
+- Added currency field
+
+## [0.0.16]
+
+- Replace the method parameter by an options parameter to allow for modification of specific HTML elements on links
+- Confirm options on links
+- Smarter merging process on HTML attributes when using link helpers
+- Use base input names and IDs in model form builder
+- Add select or create subform as a model form builder method
+- Add nested association form and related methods to models helper
+- Add shorthand methods: model_form_for, model_form_with

data/README.md

@@ -1,8 +1,6 @@
 # Pxs::Forms
 
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/pxs/forms`. To experiment with that code, run `bin/console` for an interactive prompt.
+Quick and dirty form helpers. Use this at your own peril until v0.1 because I'm still making breaking changes every now and then. 
 
 ## Installation
 
@@ -18,7 +16,7 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
 ## Usage
 
-TODO: Write usage instructions here
+Needs a few keywords defined in i18n: t('actions.edit'), t('actions.delete'), t('actions.cancel'), t('actions.create'), t('actions.update')
 
 ## Development
 

data/lib/pxs/forms/links_helper.rb

@@ -1,12 +1,75 @@
 module Pxs
     module Forms
         module LinksHelper
-            def turbo_link_button(text, target, method = :get)
-                link_to text, target, class: "button", data: { turbo_stream: true, turbo_method: method }
+            include ActionView::Helpers
+
+            # a link that triggers a turbo request
+            def turbo_link_to(text, target, options = {})
+                link_to text, target, class: options[:class] || nil, data: { turbo_stream: true, turbo_method: options[:method] || :get, turbo_confirm: options[:confirm] }, id: options[:id], title: options[:title]
+            end
+
+            # a button that triggers a turbo request
+            def turbo_link_button(text, target, options = {})
+                # inject the button class to a turbo link
+                turbo_link_to text, target, merge_option(:class, "button", options)
+            end
+
+            # a button that makes an HTML request
+            def link_button_to(text, target, options = {})
+                link_to text, target, class: merge_option(:class, "button", options)[:class], method: options[:method] || :get, id: options[:id], title: options[:title]
+            end
+
+            private
+            ## merges a @value onto @options[@key], given a set of @options
+            # set @decompose to false if the value shouldn't be split into an array if its a string, as is the case for say an HTML class that could be class="button red"
+            def merge_option(key, merged_value, options = {}, decompose = true)
+                if options.has_key? key
+
+                    # stuff both values into arrays, split if decomposing
+                    merged_values = if decompose then merged_value.split else [merged_value] end
+
+                    option_values = options[key]
+
+                    # if decomposing, split the string into an array containing each word
+                    if decompose && option_values.is_a?(String)
+                        option_values = option_values.split
+                    # for consistency, do the same with symbols as they will be processed like strings but cannot contain more than one element
+                    elsif decompose && option_values.is_a?(Symbol)
+                        option_values = [option_values.to_s]
+                    # if value is a string and decompose is set to false or if it's anything else than an array
+                    elsif (!decompose && option_values.is_a?(String)) ||!option_values.is_a?(Array)
+                        # put the value as is into an array
+                        option_values = [option_values]
+                    end
+
+                    # merged_values must always be an array here
+                    merged_values.each do |merged_value|
+                        # check for reasons not to merge the values, namely: it's already in @value
+                        unless attr_array_contains(option_values, merged_value)
+                            option_values << merged_value
+                        end
+                    end
+
+                    options[key] = option_values.join(" ")
+                # otherwise, options does not have a [key] entry
+                else
+                    # set the option as the merged_value
+                    options[key] = merged_value
+                end
+
+                options
             end
 
-            def link_button_to(text, target, method = :get)
-                link_to text, target, class: "button", method: method
+            def attr_array_contains(array = [], value = nil)
+                if value
+                    array.each do |array_value|
+                        if array_value == value || array_value =~ /^#{value} / || array_value =~ / #{value}$/ || array_value.include?(" #{value} ")
+                            return true
+                        end
+                    end
+                end
+
+                false
             end
         end
     end

data/lib/pxs/forms/model_form_builder.rb

@@ -2,6 +2,21 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
 
     delegate :tag, :safe_join, to: :@template
 
+    attr_reader :input_name_prefix, :input_id_prefix
+
+    def initialize(object_name, object, template, options, input_name_prefix = nil, input_id_prefix = nil)
+        # if input name isn't specified (which by default it isn't in the Rails vanilla form_with/for), set it from the object name
+        @input_name_prefix = input_name_prefix || object_name.to_s.underscore
+        @input_id_prefix = input_id_prefix || object_name.to_s.underscore.kebabcase
+
+        super(object_name, object, template, options)
+    end
+
+    def set_association_prefixes(name, id = "")
+        @input_name_prefix = name
+        @input_id_prefix = id
+    end
+
     def field(attribute, options = {})
         @form_options = options
         object_type = object_type_for_attribute(attribute)
@@ -9,6 +24,7 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
         input_type = case object_type
             when :date then :string
             when :integer then :string
+            when :decimal then :string
             else object_type
         end
 
@@ -21,15 +37,134 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
         send("#{override_input_type || input_type}_input", attribute, options)
     end
 
-    def radio_buttons_field(attribute, options = {})
+    def radio_buttons_input(attribute, options = {})
         collection_of(:radio_buttons, attribute, options)
     end
 
-    def check_boxes_field(attribute, options = {})
+    def check_boxes_input(attribute, options = {})
         collection_of(:check_boxes, attribute, options)
     end
 
+    # if the object is associated to other models, they can have their own subsection of a form
+    # the subsection typically includes:
+    #   * a selection input for the submodel:
+    #       usually a Select or Radio Buttons for single associations, select or checkboxes or custom components for multiple
+    #       for now this is kept outside of this form builder, could be added here
+    #   * an "add [model]" button in case the user can add the given model and the intended model does not exist yet
+    #   * a space for the submodel's form, which is displayed only as necessary
+    def association_select_or_create_subform(association, options = {})
+
+        # assert that the options hash passed contains only valid keys
+        options.assert_valid_keys(:add, :select, :collection)
+        # merge with the default options
+        options = association_select_or_create_subform_options(association).merge(options)
+
+        # use the provided collection, if any
+        collection = if options[:collection].present? then
+            options[:collection]
+        # otherwise use Association.for_select, if that method is provided
+        elsif options[:association_class].methods.include? :for_select
+            options[:association_class].for_select
+        # otherwise use Association.all
+        else
+            options[:association_class].all
+        end
+
+        # the container for the input and whatever subform might appear
+        @template.tag.div id: model_html_id(association), class: "form-section" do
+
+            safe_join [
+                # subform title, acting as the field label
+                @template.tag.h3(association.to_s.humanize, id: model_html_id(association, :title)),
+                # a select input, to choose an existing model
+                field("#{association.to_s}_id", collection: collection, text_method: options[:select][:text_method], value_method: options[:select][:value_method]),
+                # an empty "client-form" ID div, to be filled with the subform fields once expanded
+                @template.tag.div(id: model_html_id(association, :form)),
+                # an "Add Client" button, to expand the subform when clicked in order to allow the user to create a new submodel alongside the original model
+                @template.link_to(options[:add][:label], options[:add][:path], class: "button", id: model_button_id(association, :new),  data: { turbo_stream: true }),
+                # A `cancel` button to close the subform, initially hidden
+                cancel_form_button(association)
+            ]
+        end
+    end
+
+    def associated_model_subform association
+        fields_for association do |association_form|
+            @template.render("#{association_class(association).model_name.collection}/fields", form: association_form)
+        end
+    end
+
+    # cancel subform button
+    def cancel_form_button association, label = nil
+        @template.link_to(label ? label.to_.humanize : "Use Existing", new_associated_model_path(association, name: @input_name_prefix, args: {cancel: :true}), class: "button hidden", id: "cancel-#{association_class(association).model_name.singular.kebabcase}-button", data: {turbo_stream: true})
+    end
+
+    def slider_input(attribute, options = {})
+        field_block(attribute, options) do
+            safe_join [
+                (field_label(attribute, options[:label]) unless options[:label] == false),
+                tag.input(type: :range, id: "#{base_input_name}-#{attribute.to_s.kebabcase}", name: attribute.to_s.kebabcase, min: options[:min] || 0, max: options[:max] || 10, step: options[:step] || 1, value: options[:value], list: options[:datalist_id])
+            ]
+        end
+    end
+
+    # range inputs, by definition, accept two attributes, both assumed to be numerical
+    def range_input(min_attribute, max_attribute, options = {})
+        # default to lower boundary
+        #? worth forcing an error by requiring this parameter, instead of stashing in options; same for the min/max options, which are hard to give default values to
+        attribute_name = (options[:attribute_name] || min_attribute).to_s
+        field_block(attribute_name, options) do
+            safe_join [
+                (field_label(attribute_name, options[:label]) unless options[:label] == false),
+                tag.input(type: :range, id: "#{base_input_name}-#{attribute_name.kebabcase}", name: attribute_name.kebabcase, min: options[:min] || 0, max: options[:max] || 10, step: options[:step] || 1, value: options[:value], list: options[:datalist_id])
+            ]
+        end
+    end
+
+
     private
+    def cached_helpers
+        Class.new do
+            include Rails.application.routes.url_helpers
+            include Rails.application.routes.mounted_helpers
+        end.new
+    end
+
+    # if a collection is given as a hash (as it typically is for enums, for instance), it should be converted into an array in order to be fed to collection inputs
+    def collection_from_hash(collection, invert_keys_and_values: false, keys_as_label_and_text: false)
+        return collection.map {|k,v| if invert_keys_and_values then [k,v] elsif keys_as_label_and_text then [k,k] else [v,k] end}, :first, :last
+    end
+
+    def association_class(association)
+        object.class.reflect_on_association(association).klass
+    end
+
+    # calls the new_[model]_path helper function with the model contained in @association, and any params given
+    def new_associated_model_path(association, name: nil, args: {})
+        # name param is the form's path
+        cached_helpers.send("new_#{association_class(association).model_name.singular}_path", {name: name || field_name(object.class.model_name.singular, "#{association.to_s}_attributes")}.merge(args) )
+    end
+
+    # default options for an association select-or-create-with-subform field
+    def association_select_or_create_subform_options(association, name = nil)
+        # default options for the `Add` button
+        add = {
+            # add button default label
+            label: t("actions.new", thing: "#{association_class(association).model_name.human}"),
+            # add button default path
+            path: new_associated_model_path(association, name: name)
+        }
+
+        # default options for select inputs
+        select = {
+            text_method: :name,
+            value_method: :id
+        }
+
+        # save the association class as an option so it doesn't need to be called again if needed later
+        return { association_class: association_class(association), collection: [], add:, select: }
+    end
+
     def object_type_for_attribute(attribute)
         # if @object defines an attribute
         result = if @object.respond_to?(:type_for_attribute) && @object.has_attribute?(attribute)
@@ -47,6 +182,7 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
 
     def string_input(attribute, options = {})
         field_block(attribute, options) do
+
             safe_join [
                 (field_label(attribute, options[:label]) unless options[:label] == false),
                 string_field(attribute, merge_input_options({class: "#{"is-invalid" if has_error?(attribute)}"}, options[:input_html])),
@@ -66,7 +202,7 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
         field_block(attribute, options) do
             safe_join [
             (field_label(attribute, options[:label]) unless options[:label] == false),
-            text_area(attribute, merge_input_options({class: "#{"is-invalid" if has_error?(attribute)}"}, options[:input_html])),
+            text_area(base_input_name, attribute, merge_input_options({class: "#{"is-invalid" if has_error?(attribute)}", value: object[attribute]}, options[:input_html])),
             ]
         end
     end
@@ -75,8 +211,8 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
         field_block(attribute, options) do
             tag.div(class: "checkbox-field") do
             safe_join [
-                check_box(attribute, merge_input_options({class: "checkbox-input"}, options[:input_html])),
-                label(attribute, options[:label], class: "checkbox-label"),
+                check_box(base_input_name, attribute, merge_input_options({class: "checkbox-input"}, options[:input_html])),
+                label(base_input_name, attribute, options[:label], class: "checkbox-label"),
             ]
             end
         end
@@ -85,23 +221,29 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
     def collection_input(attribute, options, &block)
         field_block(attribute, options) do
             safe_join [
-                label(attribute, options[:label]),
+                options[:label] ? nil : label(object.class.to_s.underscore.downcase.to_sym, attribute, options[:label] || object.class.human_attribute_name(attribute)),
                 block.call,
             ]
         end
     end
 
     def select_input(attribute, options = {})
-
-        value_method = options[:value_method] || :id
-        text_method = options[:text_method] || :name
+        # hash collections are a special case
+        if options[:collection].is_a? Hash
+            options[:collection], value_method, text_method = collection_from_hash(options[:collection], invert_keys_and_values: options[:invert_keys_and_values], keys_as_label_and_text: options[:keys_as_label_and_text])
+        else
+            value_method = options[:value_method] || :id
+            text_method = options[:text_method] || :name
+        end
         input_options = options || {}
 
         multiple = input_options[:multiple]
 
-        collection_input(attribute, options) do
-            collection_select(attribute, options[:collection], value_method, text_method, options[:select_options] || {}, merge_input_options({class: "#{"custom-select" unless multiple} #{"is-invalid" if has_error?(attribute)}"}, options[:input_html]))
-        end
+        safe_join [
+            collection_input(attribute, options) do
+                collection_select(object.class.model_name.singular.to_sym, attribute, options[:collection], value_method, text_method, {selected: object[attribute]}.merge(options[:select] || {}), merge_input_options({class: "#{"custom-select" unless multiple} #{"is-invalid" if has_error?(attribute)}"}, options[:input_html]))
+            end
+        ]
     end
 
     def grouped_select_input(attribute, options = {})
@@ -116,7 +258,7 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
         field_block(attribute, options) do
             safe_join [
                 (field_label(attribute, options[:label]) unless options[:label] == false),
-                custom_file_field(attribute, options),
+                custom_file_field(base_input_name, attribute, options),
             ]
         end
     end
@@ -132,10 +274,10 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
             safe_join [
                 field_label(attribute, options[:label]),
                 tag.div(class: "#{custom_class}-list") {
-                    (send(form_builder_method, attribute, options[:collection], options[:value_method], options[:text_method]) do |b|
+                    (send(form_builder_method, object.model_name.singular.to_sym, attribute, options[:collection], options[:value_method], options[:text_method]) do |b|
                         tag.div(class: "#{custom_class}") {
                             safe_join [
-                            b.send(input_builder_method, class: "#{custom_class}-input"),
+                            b.send(input_builder_method, {class: "#{custom_class}-input"}.merge(options[:item_html] || {}) {|k, v1, v2| [v1, v2].join(" ")}),
                             b.label(class: "#{custom_class}-label"),
                             ]
                         }
@@ -146,10 +288,12 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
     end
 
     def string_field(attribute, options = {})
+        # force the default value against the object's attribute, because using :object in lieu of the object name will yield HTML elements with name="object[some_attribute]" instead of the proper name
+        options = { value: object[attribute] }.merge(options)
         case object_type_for_attribute(attribute)
         when :date then
             safe_join [
-                date_field(attribute, merge_input_options(options, {data: {datepicker: true}})),
+                date_field(base_input_name, attribute, merge_input_options(options, {data: {datepicker: true}})),
                 tag.div {
                     date_select(attribute, {
                             order: [:year, :month, :day],
@@ -158,19 +302,18 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
                         }, {data: {date_select: true}})
                 },
             ]
-        when :datetime then
-            datetime_field(attribute, options)
-        when :integer then number_field(attribute, options)
+        when :integer then number_field(base_input_name, attribute, options)
+        when :decimal then number_field(base_input_name, attribute, {step: 0.1}.merge(options))
         when :string
             case attribute.to_s
-            when /password/ then password_field(attribute, options)
+            when /password/ then password_field(base_input_name, attribute, options)
             # when /time_zone/ then :time_zone
             # when /country/   then :country
-            when /email/ then email_field(attribute, options)
-            when /phone/ then telephone_field(attribute, options)
-            when /url/ then url_field(attribute, options)
+            when /email/ then email_field(base_input_name, attribute, options)
+            when /phone/ then telephone_field(base_input_name, attribute, options)
+            when /url/ then url_field(base_input_name, attribute, options)
             else
-                text_field(attribute, options)
+                text_field(base_input_name, attribute, options)
             end
         end
     end
@@ -186,7 +329,7 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
     end
 
     def field_label(attribute, options = {})
-        label(attribute, options)
+        label(object.class.model_name.singular_route_key.kebabcase.to_sym, I18n.t("activerecord.attributes.#{object.class.model_name.singular}.#{attribute}", default: attribute), options)
     end
 
     def hint_text(text)
@@ -197,7 +340,7 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
 
     def error_text(attribute)
         if has_error? attribute
-            tag.div @object.errors[attribute].join("<br />").html_safe, class: "form-errors"
+            tag.div @object.errors[method].join("<br />").html_safe, class: "form-errors"
         end
     end
 
@@ -206,10 +349,18 @@ class ModelFormBuilder < ActionView::Helpers::FormBuilder
         @object.errors.key?(attribute)
     end
 
-    def merge_input_options(options, user_options)
-        return options if user_options.nil?
+    def merge_input_options(options, user_options = nil)
+        options = if user_options.nil?
+            options
+        else
+            options.merge(user_options)
+        end
+
+        # filter out hash keys with an empty/nil value
+        options.filter do |key,value| value.present? end
+    end
 
-        # TODO handle class merging here
-        options.merge(user_options)
+    def base_input_name
+        @input_name_prefix || @object.class.model_name.singular.to_sym
     end
 end

data/lib/pxs/forms/models_helper.rb

@@ -1,43 +1,91 @@
 module Pxs
     module Forms
         module ModelsHelper
+            include LinksHelper
+            include ActionView::Context
+
             # base_path: the model's CRUD base path as an URL string, like the result of article_path(:id)
-            def model_edit_delete_actions(base_path)
+            def model_edit_delete_actions(base_path, options = {})
                 [
                     # edit model button
-                    model_edit_action(base_path),
+                    model_edit_action(base_path, options[:edit_label]),
                     # delete model button
-                    model_delete_action(base_path)
+                    model_delete_action(base_path, options[:delete_label])
                 ].join('').html_safe
             end
 
-            def model_edit_action(base_path)
+            # "Edit" model button
+            def model_edit_action(base_path, label = nil)
                 #! maybe there's a safer way to do the route but this works as long as rails routing naming conventions hold
-                turbo_link_button(t('keywords.edit'), "#{base_path}/edit")
+                turbo_link_button(label || t('keywords.edit'), "#{base_path}/edit")
+            end
+
+            # "Delete" model button
+            def model_delete_action(base_path, label = nil)
+                turbo_link_button(label || t('keywords.delete'), base_path, method: :delete )
+            end
+
+            # "New" model button
+            def model_new_action(base_path, label = nil)
+                turbo_link_button(label || t('keywords.new'), "#{base_path}/new")
+            end
+
+            # "Cancel" new model button
+            def model_cancel_form_button(base_path, label = nil)
+                turbo_link_button(label || t('keywords.cancel'), "#{base_path}?cancel=true")
             end
 
-            def model_delete_action(base_path)
-                turbo_link_button(t('keywords.delete'), base_path, :delete )
+            # "Create"/"Update" model model
+            def model_submit_button(form, label = nil)
+                # adjust the label depending on whether the form's object has already been created or not
+                label = label || "#{(form.object.new_record? ? t("keywords.create") : t("keywords.update"))} #{form.object.class.to_s}"
+                form.submit label
             end
 
-            def model_cancel_form_button(base_path)
-                turbo_link_button(t('keywords.cancel'), "#{base_path}/0")
+            # Model element HTML tag ID
+            def model_html_id(model, suffix = "")
+                # model-suffix, or only model if no suffix is provided
+                "#{model_string(model).kebabcase}#{suffix.present? ? "-#{suffix.to_s.kebabcase}" : ""}"
+            end
+
+            # Model subform title HTML ID
+            def model_title_id(model)
+                # some-model-title
+                model_html_id model.class.model_name.singular.kebabcase, :title
+            end
+
+            # Model subform <form> HTML ID
+            def model_form_id(model)
+                # use the model class, not the model itself
+                if model.is_a? ActiveRecord::Base
+                    model_class = model
+                else
+                    model_class = model.class
+                end
+
+                model_html_id model_class.model_name.singular.kebabcase, :form
             end
 
-            def model_submit_button(form)
-                form.submit "#{form.object.new_record? ? "Create" : "Update"} #{form.object.class.to_s}"
+            # shorthand to set model form button IDs
+            # for instance, model_button_id(client, :new) == 'new-client-button'
+            def model_button_id(model, button_action = nil)
+                model_html_id "#{button_action.present? ? "#{button_action.to_s.kebabcase}-" : ""}#{model_string(model).kebabcase}", :button
             end
 
+            # standardized form call for models (using form_for)
             def model_form_for(name, *args, &block)
                 # set ModelFormBuilder as the form builder
+                #! can be avoided by setting ModelFormBuilder as default in config
                 options = args.extract_options!.merge(builder: ModelFormBuilder)
 
+                #! use merge_option
                 if options.has_key? :class
                     options[:class] << " form"
                 else
                     options[:class] = "form"
                 end
 
+                # separate HTML options due to form_for parameter strucutre
                 options[:html] = { class: options[:class] }
 
                 args << options
@@ -45,10 +93,121 @@ module Pxs
                 form_for(name, *args, &block)
             end
 
-            def model_form_with(model: nil, scope: nil, url: nil, format: nil, **options, &block)
+            # standardized form call for models (using form_with)
+            def model_form_with(model, scope: nil, url: nil, format: nil, **options, &block)
+                # set custom form builder (!should be done in config)
                 options = options.reverse_merge(builder: ModelFormBuilder)
+
+                # make the call
                 form_with(model: model, scope: scope, url: url, format: format, class: "form#{(options.has_key? :class) ? " #{options[:class]}" : ""}", **options, &block)
             end
+
+            #!? what does this do again?
+            def model_string model
+                if model.is_a? String
+                    model
+                elsif model.is_a? ActiveRecord::Base || model.respond_to?(model_name)
+                    model.model_name.singular
+                else
+                    model.to_s
+                end
+            end
+
+            # form_name => a string that matches the input elements HTML name attribute, like "project[client][contacts][0][coordinate]"
+            def model_association_form(form_name = "")
+
+                # isolate the original model class from the submodels
+                form_model, *nested_attributes = form_name.split(/\[|\]/).compact_blank
+
+                # simulate the top-level form using a new instance of form_model
+                fields form_model.classify.constantize.new do |form|
+                    form.set_association_prefixes(form_name)
+
+                    # recursively build the subforms, going as deep as needed to reach the association model form
+                    nested_form_builder_for form, nested_attributes do |nested_form|
+
+                        # run once for the last iteration (the association model)
+                        return nested_form
+                    end
+                end
+            end
+
+            # to convert something like "project[client_attributes]" to "project-client"
+            def input_name_to_id(name)
+                match = match_model_input_name name
+
+                # return nil on bad input
+                return nil unless match
+
+                # create a working copy because will be modified later
+                working_name = name
+
+                # first capture group is the starting point of the ID, to kebabcase
+                id = match[1].kebabcase
+
+                loop do
+                    if match[2]
+
+                        # only match with character strings, ignore indexes for now
+                        #! might lead to some issues if ever there comes a point where this is used in one-to-many relationships with multiple models displayed on the same page
+                        if association = match[2].match(/\[([A-Za-z_]+)\]/)
+                            id << "-#{association[1].kebabcase}"
+                        end
+                    end
+
+                    # break after the first check, so the first set of bracket is processed coming into the loop
+                    break unless match[2]
+
+                    # remove the first set of [] from the name string, intending to repeat the process over and over until each has been removed
+                    working_name.gsub!(match[2], "")
+
+                    # match again
+                    match = match_model_input_name working_name
+                end
+
+                # id should contain the base model and associated models in a kebabcase string, like "project-client-contacts-first-name"
+                id
+            end
+
+            def input_name_to_select_id(name)
+                match = match_model_input_name name
+
+                return nil unless match[3]
+
+                object_name = match[1]
+                association_name = match[3].chomp("_attributes")
+
+                "#{object_name}_#{association_name}"
+            end
+
+            private
+            def match_model_input_name(name)
+                name.match(/([A-Za-z]+)(\[([a-zA-Z_]+|[\d]+)\])?/)
+            end
+            # recursively build a nested form from a given form builder and nested_attributes, which more or less matches the name="" HTML attribute of the input fields that must ultimately be produced
+            def nested_form_builder_for form, *nested_attributes, &block
+
+                # fetch the attribute and potential index from the nested attributes
+                attribute, index = nested_attributes.flatten!.shift(2)
+
+                if attribute.blank?
+                    # if running out of attributes, render the last form builder instance to generate the response
+                    yield form
+                    return
+                end
+
+                # get the assoication from the attribute name, if applicable
+                association = attribute.chomp("_attributes")
+
+                # set the index, generate a unique one if none was provided in the nested attributes
+                child_index = index || Process.clock_gettime(Process::CLOCK_REALTIME, :millisecond)
+
+                return form.fields_for association, association.classify.constantize.new, child_index: do |association_form|
+
+                    association_form.set_association_prefixes(form.input_name_prefix, form.input_id_prefix)
+                    nested_form_builder_for association_form, nested_attributes, &block
+                end
+            end
         end
     end
 end

data/lib/pxs/forms/version.rb

@@ -2,6 +2,6 @@
 
 module Pxs
   module Forms
-    VERSION = "0.0.15"
+    VERSION = "0.0.17"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pxs-forms
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.17
 platform: ruby
 authors:
 - Poubelle
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-05-05 00:00:00.000000000 Z
+date: 2025-03-01 00:00:00.000000000 Z
 dependencies: []
 description: 
 email: