form_props 0.0.1

data/lib/form_props/action_view_extensions/form_helper.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module FormProps
+  module ActionViewExtensions
+    module FormHelper
+      def form_props(model: nil, scope: nil, url: nil, format: nil, **options, &block)
+        json = @__json
+
+        options = {
+          allow_method_names_outside_object: true,
+          controlled: false
+        }.merge!(options)
+
+        options.delete(:remote)
+
+        options[:local] = true
+        options[:skip_default_ids] = false
+
+        if model
+          if url != false
+            url ||= if format.nil?
+              polymorphic_path(model, {})
+            else
+              polymorphic_path(model, format: format)
+            end
+          end
+
+          model = convert_to_model(_object_for_form_builder(model))
+          scope ||= model_name_from_record_or_class(model).param_key
+        end
+
+        if block
+          options[:builder] = FormProps::FormBuilder
+
+          builder = instantiate_builder(scope, model, options)
+          json.inputs do
+            capture(builder, &block)
+          end
+          options[:multipart] ||= builder.multipart?
+        end
+
+        html_options = html_options_for_form_with(url, model, **options)
+
+        json.extras do
+          extra_props_for_form(json, html_options)
+        end
+        json.props(html_options)
+      end
+
+      private
+
+      def token_props(json, token = nil, form_options: {})
+        if token != false && defined?(protect_against_forgery?) && protect_against_forgery?
+          token =
+            if token == true || token.nil?
+              form_authenticity_token(form_options: form_options.merge(authenticity_token: token))
+            else
+              token
+            end
+
+          json.set!("csrf") do
+            json.name request_forgery_protection_token.to_s
+            json.type "hidden"
+            json.default_value token
+            json.autocomplete "off"
+          end
+        end
+      end
+
+      def method_props(json, method)
+        json.set!("method") do
+          json.name "_method"
+          json.type "hidden"
+          json.default_value method.to_s
+          json.autocomplete "off"
+        end
+      end
+
+      def utf8_enforcer_props(json)
+        json.set!("utf8") do
+          json.name "utf8"
+          json.type "hidden"
+          json.default_value "✓"
+          json.autocomplete "off"
+        end
+      end
+
+      def extra_props_for_form(json, html_options)
+        authenticity_token = html_options.delete("authenticity_token")
+        method = html_options.delete("method").to_s.downcase
+
+        case method
+        when "get"
+          html_options["method"] = "get"
+        when "post", ""
+          html_options["method"] = "post"
+          token_props(json, authenticity_token, form_options: {
+            action: html_options["action"],
+            method: "post"
+          })
+        else
+          html_options["method"] = "post"
+          method_props(json, method)
+          token_props(json, authenticity_token, form_options: {
+            action: html_options["action"],
+            method: method
+          })
+        end
+
+        if html_options.delete("enforce_utf8") { default_enforce_utf8 }
+          utf8_enforcer_props(json)
+        end
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_view) do
+  include FormProps::ActionViewExtensions::FormHelper
+end

data/lib/form_props/form_builder.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module FormProps
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    undef_method :button,
+      :label,
+      :datetime_select,
+      :time_select,
+      :date_select
+    # :rich_text_area
+
+    def initialize(*args)
+      super
+      options = args.last || {}
+      @default_options[:controlled] = options[:controlled]
+      @default_html_options = @default_html_options.except(:controlled)
+    end
+
+    def file_field(method, options = {})
+      Inputs::FileField.new(
+        @object_name,
+        method,
+        @template,
+        @template.send(:convert_direct_upload_option_to_url, objectify_options(options).dup)
+      ).render
+    end
+
+    def select(method, choices = [], options = {}, html_options = {})
+      Inputs::Select.new(@object_name, method, @template, choices, objectify_options(options), @default_html_options.merge(html_options)).render
+    end
+
+    def hidden_field(method, options = {})
+      Inputs::HiddenField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def text_field(method, options = {})
+      Inputs::TextField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def date_field(method, options = {})
+      Inputs::DateField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def time_field(method, options = {})
+      Inputs::TimeField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def week_field(method, options = {})
+      Inputs::WeekField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def month_field(method, options = {})
+      Inputs::MonthField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def datetime_field(method, options = {})
+      Inputs::DatetimeLocalField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def datetime_local_field(method, options = {})
+      Inputs::DatetimeLocalField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def url_field(method, options = {})
+      Inputs::UrlField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def tel_field(method, options = {})
+      Inputs::TelField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def color_field(method, options = {})
+      Inputs::ColorField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def password_field(method, options = {})
+      Inputs::PasswordField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def number_field(method, options = {})
+      Inputs::NumberField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def range_field(method, options = {})
+      Inputs::RangeField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def email_field(method, options = {})
+      Inputs::EmailField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def search_field(method, options = {})
+      Inputs::SearchField.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def text_area(method, options = {})
+      Inputs::TextArea.new(@object_name, method, @template, objectify_options(options)).render
+    end
+
+    def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+      Inputs::CheckBox.new(@object_name, method, @template, checked_value, unchecked_value, objectify_options(options)).render
+    end
+
+    def radio_button(method, tag_value, options = {})
+      Inputs::RadioButton.new(@object_name, method, @template, tag_value, options).render
+    end
+
+    def collection_select(method, collection, value_method, text_method, options = {}, html_options = {})
+      Inputs::CollectionSelect.new(@object_name, method, @template, collection, value_method, text_method, objectify_options(options), @default_html_options.merge(html_options)).render
+    end
+
+    def collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      Inputs::CollectionCheckBoxes.new(@object_name, method, @template, collection, value_method, text_method, objectify_options(options), @default_html_options.merge(html_options), &block).render
+    end
+
+    def collection_radio_buttons(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      Inputs::CollectionRadioButtons.new(@object_name, method, @template, collection, value_method, text_method, objectify_options(options), @default_html_options.merge(html_options), &block).render
+    end
+
+    def grouped_collection_select(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+      Inputs::GroupedCollectionSelect.new(@object_name, method, @template, collection, group_method, group_label_method, option_key_method, option_value_method, objectify_options(options), @default_html_options.merge(html_options)).render
+    end
+
+    def time_zone_select(method, priority_zones = nil, options = {}, html_options = {})
+      Inputs::TimeZoneSelect.new(@object_name, method, @template, priority_zones, objectify_options(options), @default_html_options.merge(html_options)).render
+    end
+
+    def weekday_select(method, options = {}, html_options = {})
+      Inputs::WeekdaySelect.new(@object_name, method, @template, objectify_options(options), @default_html_options.merge(html_options)).render
+    end
+
+    def submit(value = nil, options = {})
+      value, options = nil, value if value.is_a?(Hash)
+      value ||= submit_default_value
+      options = {name: "commit", value: value}.update(options)
+
+      Inputs::Submit.new(@template, options).render
+    end
+
+    def fields_for_with_nested_attributes(association_name, association, options, block)
+      name = "#{object_name}[#{association_name}_attributes]"
+      association = convert_to_model(association)
+
+      if association.respond_to?(:persisted?)
+        association = [association] if @object.public_send(association_name).respond_to?(:to_ary)
+      elsif !association.respond_to?(:to_ary)
+        association = @object.public_send(association_name)
+      end
+
+      if association.respond_to?(:to_ary)
+        explicit_child_index = options[:child_index]
+
+        @template.json.set!("#{association_name}_attributes") do
+          @template.json.array! association do |child|
+            if explicit_child_index
+              options[:child_index] = explicit_child_index.call if explicit_child_index.respond_to?(:call)
+            else
+              options[:child_index] = nested_child_index(name)
+            end
+
+            fields_for_nested_model("#{name}[#{options[:child_index]}]", child, options, block)
+          end
+        end
+      elsif association
+        @template.json.set!("#{association_name}_attributes") do
+          fields_for_nested_model(name, association, options, block)
+        end
+      end
+    end
+
+    def fields_for_nested_model(name, object, fields_options, block)
+      object = convert_to_model(object)
+      emit_hidden_id = object.persisted? && fields_options.fetch(:include_id) {
+        options.fetch(:include_id, true)
+      }
+
+      @template.fields_for(name, object, fields_options) do |f|
+        block.call(f)
+        f.hidden_field(:id) if emit_hidden_id && !f.emitted_hidden_id?
+      end
+    end
+
+    def fields_for(record_name, record_object = nil, fields_options = {}, &block)
+      fields_options, record_object = record_object, nil if record_object.is_a?(Hash) && record_object.extractable_options?
+      fields_options[:builder] ||= self.class
+      fields_options[:namespace] = options[:namespace]
+      fields_options[:parent_builder] = self
+
+      case record_name
+      when String, Symbol
+        if nested_attributes_association?(record_name)
+          return fields_for_with_nested_attributes(record_name, record_object, fields_options, block)
+        end
+      else
+        record_object = record_name.is_a?(Array) ? record_name.last : record_name
+        record_name = model_name_from_record_or_class(record_object).param_key
+      end
+
+      object_name = @object_name
+      index = if options.has_key?(:index)
+        options[:index]
+      elsif defined?(@auto_index)
+        object_name = object_name.to_s.delete_suffix("[]")
+        @auto_index
+      end
+
+      record_name = if index
+        "#{object_name}[#{index}][#{record_name}]"
+      elsif record_name.end_with?("[]")
+        "#{object_name}[#{record_name[0..-3]}][#{record_object.id}]"
+      else
+        "#{object_name}[#{record_name}]"
+      end
+      fields_options[:child_index] = index
+
+      @template.fields_for(record_name, record_object, fields_options, &block)
+    end
+
+    def default_form_builder_class
+      self.class
+    end
+  end
+end

data/lib/form_props/form_options_helper.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module FormProps
+  module FormOptionsHelper
+    def selected_values
+      @selected_values ||= []
+      @selected_values
+    end
+
+    def grouped_options_for_select(grouped_options, selected_key = nil, options = {})
+      prompt = options[:prompt]
+      divider = options[:divider]
+
+      options = []
+
+      if prompt
+        options.push({
+          label: prompt_text(prompt),
+          value: ""
+        })
+      end
+
+      grouped_options.each do |container|
+        html_attributes = option_html_attributes(container)
+
+        if divider
+          label = divider
+        else
+          label, container = container
+        end
+
+        options.push({label: label, options: options_for_select(container, selected_key)}
+          .merge!(html_attributes))
+      end
+
+      options
+    end
+
+    def option_html_attributes(element)
+      if Array === element
+        element.select { |e| Hash === e }.reduce({}, :merge!)
+      else
+        {}
+      end
+    end
+
+    def options_for_select(container, selected = nil)
+      selected, disabled = extract_selected_and_disabled(selected).map do |r|
+        Array(r).map(&:to_s)
+      end
+
+      container.map do |element|
+        html_attributes = option_html_attributes(element)
+        text, value = option_text_and_value(element).map(&:to_s)
+
+        if !html_attributes[:selected] && option_value_selected?(value, selected)
+          selected_values.push(value)
+        end
+
+        if html_attributes[:selected]
+          selected_values.push(value)
+        end
+
+        if !html_attributes[:disabled] && (disabled && option_value_selected?(value, disabled))
+          html_attributes[:disabled] = true
+        end
+
+        html_attributes[:value] = value
+        html_attributes[:label] = text
+
+        html_attributes
+      end
+    end
+
+    def option_groups_from_collection_for_select(collection, group_method, group_label_method, option_key_method, option_value_method, selected_key = nil)
+      collection.map do |group|
+        option_tags = options_from_collection_for_select(
+          value_for_collection(group, group_method),
+          option_key_method,
+          option_value_method,
+          selected_key
+        )
+
+        {
+          options: option_tags,
+          label: value_for_collection(group, group_label_method)
+        }
+      end
+    end
+
+    def options_from_collection_for_select(collection, value_method, text_method, selected = nil)
+      options = collection.map do |element|
+        [value_for_collection(element, text_method), value_for_collection(element, value_method), option_html_attributes(element)]
+      end
+      selected, disabled = extract_selected_and_disabled(selected)
+      select_deselect = {
+        selected: extract_values_from_collection(collection, value_method, selected),
+        disabled: extract_values_from_collection(collection, value_method, disabled)
+      }
+
+      options_for_select(options, select_deselect)
+    end
+
+    def value_for_collection(item, value)
+      value.respond_to?(:call) ? value.call(item) : item.public_send(value)
+    end
+
+    def extract_selected_and_disabled(selected)
+      if selected.is_a?(Proc)
+        [selected, nil]
+      else
+        selected = Array.wrap(selected)
+        options = selected.extract_options!.symbolize_keys
+        selected_items = options.fetch(:selected, selected)
+        [selected_items, options[:disabled]]
+      end
+    end
+
+    def extract_values_from_collection(collection, value_method, selected)
+      if selected.is_a?(Proc)
+        collection.map do |element|
+          element.public_send(value_method) if selected.call(element)
+        end.compact
+      else
+        selected
+      end
+    end
+
+    def time_zone_options_for_select(selected = nil, priority_zones = nil, model = ::ActiveSupport::TimeZone)
+      zone_options = []
+
+      zones = model.all
+      convert_zones = lambda { |list| list.map { |z| [z.to_s, z.name] } }
+
+      if priority_zones
+        if priority_zones.is_a?(Regexp)
+          priority_zones = zones.select { |z| z.match?(priority_zones) }
+        end
+
+        zone_options.concat(options_for_select(convert_zones[priority_zones], selected))
+        zone_options.push({label: "-------------", value: "", disabled: true})
+
+        zones -= priority_zones
+      end
+
+      zone_options.concat(options_for_select(convert_zones[zones], selected))
+      zone_options
+    end
+
+    def weekday_options_for_select(selected = nil, index_as_value: false, day_format: :day_names, beginning_of_week: Date.beginning_of_week)
+      day_names = I18n.translate("date.#{day_format}")
+      day_names = day_names.map.with_index.to_a if index_as_value
+      day_names = day_names.rotate(Date::DAYS_INTO_WEEK.fetch(beginning_of_week))
+
+      options_for_select(day_names, selected)
+    end
+  end
+end

data/lib/form_props/inputs/base.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module FormProps
+  module Inputs
+    class Base < ::ActionView::Helpers::Tags::Base
+      def json
+        @json ||= @template_object.instance_variable_get(:@__json)
+      end
+
+      def initialize(object_name, method_name, template_object, options = {})
+        options = options.with_indifferent_access
+
+        @controlled = options.delete(:controlled)
+        super(object_name, method_name, template_object, options)
+      end
+
+      private
+
+      def add_options(option_tags, options, value = nil)
+        if options[:include_blank]
+          content = (options[:include_blank] if options[:include_blank].is_a?(String))
+          label = (" " unless content)
+          option_tags = [{label: content || label, value: ""}] + option_tags
+        end
+
+        if value.blank? && options[:prompt]
+          tag_options = {value: ""}.tap do |prompt_opts|
+            prompt_opts[:disabled] = true if options[:disabled] == ""
+            if options[:selected] == ""
+              selected_values.push("")
+            end
+            prompt_opts[:label] = prompt_text(options[:prompt])
+          end
+          option_tags = [tag_options] + option_tags
+        end
+
+        option_tags
+      end
+
+      def input_props(options)
+        return if options.blank?
+
+        options.each_pair do |key, value|
+          type = TAG_TYPES[key]
+
+          if type == :data && value.is_a?(Hash)
+            value.each_pair do |k, v|
+              next if v.nil?
+              prefix_tag_props(key, k, v)
+            end
+          elsif type == :aria && value.is_a?(Hash)
+            value.each_pair do |k, v|
+              next if v.nil?
+
+              case v
+              when Array, Hash
+                tokens = build_values(v)
+                next if tokens.none?
+
+                v = safe_join(tokens, " ")
+              else
+                v = v.to_s
+              end
+
+              prefix_tag_props(key, k, v)
+            end
+          elsif key == "class" || key == :class
+            value = build_values(value).join(" ")
+            key = "class_name"
+            tag_option(key, value)
+          elsif !value.nil?
+            if key.to_s == "value"
+              key = key.to_s
+              value = value.is_a?(Array) ? value : value.to_s
+            end
+            tag_option(key, value)
+          end
+        end
+      end
+
+      def tag_option(key, value)
+        if value.is_a? Regexp
+          value = value.source
+        end
+
+        @controlled ||= nil
+
+        if !@controlled
+          if key.to_sym == :value
+            key = "default_value"
+          end
+
+          if key.to_sym == :checked
+            key = "default_checked"
+          end
+        end
+
+        json.set!(key, value)
+      end
+
+      def prefix_tag_props(prefix, key, value)
+        key = "#{prefix}-#{key.to_s.dasherize}"
+        unless value.is_a?(String) || value.is_a?(Symbol) || value.is_a?(BigDecimal)
+          value = value.to_json
+        end
+        tag_option(key, value)
+      end
+
+      def build_values(*args)
+        tag_values = []
+
+        args.each do |tag_value|
+          case tag_value
+          when Hash
+            tag_value.each do |key, val|
+              tag_values << key.to_s if val && key.present?
+            end
+          when Array
+            tag_values.concat build_values(*tag_value)
+          else
+            tag_values << tag_value.to_s if tag_value.present?
+          end
+        end
+
+        tag_values
+      end
+
+      def select_content_props(option_tags, options, html_options)
+        html_options = html_options.stringify_keys
+        add_default_name_and_id(html_options)
+
+        if placeholder_required?(html_options)
+          raise ArgumentError, "include_blank cannot be false for a required field." if options[:include_blank] == false
+          options[:include_blank] ||= true unless options[:prompt]
+        end
+
+        html_options["type"] = "select"
+        value_for_blank = options.fetch(:selected) { value }
+        option_tags = add_options(option_tags, options, value_for_blank)
+
+        if options[:multiple]
+          html_options["multiple"] = options[:multiple]
+        end
+
+        if selected_values.any?
+          html_options["value"] ||= if html_options["multiple"]
+            Array(selected_values)
+          else
+            selected_values.first
+          end
+        end
+
+        json.set!(sanitized_method_name) do
+          input_props(html_options)
+
+          if options.key?(:include_hidden)
+            json.include_hidden options[:include_hidden]
+          end
+          json.options(option_tags)
+        end
+      end
+    end
+  end
+end