phlexi-form 0.2.0 → 0.3.0.rc1

data/lib/phlexi/form/components/concerns/has_options.rb

@@ -19,13 +19,17 @@ module Phlexi
           end
 
           def selected?(option)
-            if field.multiple?
+            if attributes[:multiple]
               @options_list ||= Array(field.value)
               @options_list.any? { |item| item.to_s == option.to_s }
             else
-              field.dom.value == option.to_s
+              field.value.to_s == option.to_s
             end
           end
+
+          def normalize_simple_input(input_value)
+            ([super] & option_mapper.values)[0]
+          end
         end
       end
     end

data/lib/phlexi/form/components/concerns/submits_form.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      module Concerns
+        module SubmitsForm
+          def submit_type_value
+            if field.object.respond_to?(:persisted?)
+              field.object.persisted? ? :update : :create
+            else
+              :submit
+            end
+          end
+
+          def submit_type_label
+            @submit_type_label ||= begin
+              key = submit_type_value
+
+              model_object = field.dom.lineage.first.key.to_s
+              model_name_human = if field.object.respond_to?(:model_name)
+                field.object.model_name.human
+              else
+                model_object.humanize
+              end
+
+              defaults = []
+              defaults << :"helpers.submit.#{model_object}.#{key}"
+              defaults << :"helpers.submit.#{key}"
+              defaults << "#{key.to_s.humanize} #{model_name_human}"
+
+              I18n.t(defaults.shift, model: model_name_human, default: defaults)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/components/file_input.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class FileInput < Input
+        def view_template
+          input(type: :hidden, name: attributes[:name], value: "", autocomplete: "off", hidden: true) if include_hidden?
+          input(**attributes)
+        end
+
+        protected
+
+        def build_input_attributes
+          attributes[:type] = :file
+          super
+          attributes[:value] = false
+        end
+
+        def include_hidden?
+          return false if @include_hidden == false
+
+          attributes[:multiple]
+        end
+
+        def normalize_input(input_value)
+          input_value
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/components/input.rb

@@ -4,6 +4,8 @@ module Phlexi
   module Form
     module Components
       class Input < Base
+        include Concerns::HandlesInput
+
         def view_template
           input(**attributes)
         end
@@ -15,6 +17,7 @@ module Phlexi
 
           # only overwrite id if it was set in Base
           attributes[:id] = field.dom.id if attributes[:id] == "#{field.dom.id}_#{component_name}"
+
           attributes[:name] = field.dom.name
           attributes[:value] = field.dom.value
 
@@ -22,54 +25,57 @@ module Phlexi
         end
 
         def build_input_attributes
-          attributes[:type] = attributes.fetch(:type, field.input_type)
-          attributes[:disabled] = attributes.fetch(:disabled, field.disabled?)
+          attributes.fetch(:type) { attributes[:type] = field.inferred_input_type }
+          attributes.fetch(:disabled) { attributes[:disabled] = field.disabled? }
 
           case attributes[:type]
           when :text, :password, :email, :tel, :url, :search
-            attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
-            attributes[:placeholder] = attributes.fetch(:placeholder, field.placeholder)
-            attributes[:minlength] = attributes.fetch(:minlength, field.minlength)
-            attributes[:maxlength] = attributes.fetch(:maxlength, field.maxlength)
-            attributes[:readonly] = attributes.fetch(:readonly, field.readonly?)
-            attributes[:required] = attributes.fetch(:required, field.required?)
-            attributes[:pattern] = attributes.fetch(:pattern, field.pattern)
+            attributes.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
+            attributes.fetch(:placeholder) { attributes[:placeholder] = field.placeholder }
+            attributes.fetch(:minlength) { attributes[:minlength] = field.minlength }
+            attributes.fetch(:maxlength) { attributes[:maxlength] = field.maxlength }
+            attributes.fetch(:readonly) { attributes[:readonly] = field.readonly? }
+            attributes.fetch(:required) { attributes[:required] = field.required? }
+            attributes.fetch(:pattern) { attributes[:pattern] = field.pattern }
           when :number
-            attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
-            attributes[:placeholder] = attributes.fetch(:placeholder, field.placeholder)
-            attributes[:readonly] = attributes.fetch(:readonly, field.readonly?)
-            attributes[:required] = attributes.fetch(:required, field.required?)
-            attributes[:min] = attributes.fetch(:min, field.min)
-            attributes[:max] = attributes.fetch(:max, field.max)
-            attributes[:step] = attributes.fetch(:step, field.step)
+            attributes.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
+            attributes.fetch(:placeholder) { attributes[:placeholder] = field.placeholder }
+            attributes.fetch(:readonly) { attributes[:readonly] = field.readonly? }
+            attributes.fetch(:required) { attributes[:required] = field.required? }
+            attributes.fetch(:min) { attributes[:min] = field.min }
+            attributes.fetch(:max) { attributes[:max] = field.max }
+            attributes.fetch(:step) { attributes[:step] = field.step }
           when :checkbox, :radio
-            attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
-            attributes[:required] = attributes.fetch(:required, field.required?)
+            attributes.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
+            attributes.fetch(:required) { attributes[:required] = field.required? }
           when :file
-            attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
-            attributes[:required] = attributes.fetch(:required, field.required?)
-            attributes[:multiple] = attributes.fetch(:multiple, field.multiple)
-            attributes[:accept] = attributes.fetch(:accept, field.accept)
+            attributes.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
+            attributes.fetch(:required) { attributes[:required] = field.required? }
+            attributes.fetch(:multiple) { attributes[:multiple] = field.multiple? }
           when :date, :time, :datetime_local
-            attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
-            attributes[:readonly] = attributes.fetch(:readonly, field.readonly?)
-            attributes[:required] = attributes.fetch(:required, field.required?)
-            attributes[:min] = attributes.fetch(:min, field.min)
-            attributes[:max] = attributes.fetch(:max, field.max)
+            attributes.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
+            attributes.fetch(:readonly) { attributes[:readonly] = field.readonly? }
+            attributes.fetch(:required) { attributes[:required] = field.required? }
+            attributes.fetch(:min) { attributes[:min] = field.min }
+            attributes.fetch(:max) { attributes[:max] = field.max }
           when :color
-            attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
+            attributes.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
           when :range
-            attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
-            attributes[:min] = attributes.fetch(:min, field.min)
-            attributes[:max] = attributes.fetch(:max, field.max)
-            attributes[:step] = attributes.fetch(:step, field.step)
+            attributes.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
+            attributes.fetch(:min) { attributes[:min] = field.min }
+            attributes.fetch(:max) { attributes[:max] = field.max }
+            attributes.fetch(:step) { attributes[:step] = field.step }
+          when :hidden
+            attributes[:class] = false
+            attributes[:hidden] = true
+            attributes[:autocomplete] = "off"
           else
             # Handle any unrecognized input types
             # Rails.logger.warn("Unhandled input type: #{attributes[:type]}")
           end
 
           if (attributes[:type] == :file) ? attributes[:multiple] : attributes.delete(:multiple)
-            attributes[:name] = "#{attributes[:name].sub(/\[]$/, "")}[]"
+            attributes[:name] = "#{attributes[:name].sub(/\[\]$/, "")}[]"
           end
         end
       end

data/lib/phlexi/form/components/input_array.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class InputArray < Base
+        include Concerns::HandlesInput
+        include Concerns::HandlesArrayInput
+
+        def view_template
+          div(**attributes.slice(:id, :class)) do
+            field.multi(values.length) do |builder|
+              render builder.hidden_field_tag if builder.index == 0
+
+              field = builder.field(
+                label: builder.key,
+                # we expect key to be an integer string starting from "1"
+                value: values[builder.index]
+              )
+              if block_given?
+                yield field
+              else
+                render field.input_tag
+              end
+            end
+          end
+        end
+
+        protected
+
+        def build_attributes
+          super
+
+          attributes[:multiple] = true
+        end
+
+        private
+
+        def values
+          @values ||= Array(field.value)
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/components/label.rb

@@ -18,7 +18,8 @@ module Phlexi
 
         def build_attributes
           super
-          attributes[:for] ||= field.dom.id
+
+          attributes.fetch(:for) { attributes[:for] = field.dom.id }
         end
       end
     end

data/lib/phlexi/form/components/radio_button.rb

@@ -8,6 +8,11 @@ module Phlexi
           input(**attributes, value: @checked_value)
         end
 
+        def extract_input(...)
+          # when a radio is not submitted, nothing is returned
+          super.compact
+        end
+
         protected
 
         def build_input_attributes
@@ -17,7 +22,7 @@ module Phlexi
           @checked_value = (attributes.key?(:checked_value) ? attributes.delete(:checked_value) : "1").to_s
 
           # this is a hack to workaround the fact that radio cannot be indexed/multiple
-          attributes[:name] = attributes[:name].sub(/\[]$/, "")
+          attributes[:name] = attributes[:name].sub(/\[\]$/, "")
           attributes[:value] = @checked_value
           attributes[:checked] = attributes.fetch(:checked) { checked? }
         end
@@ -25,6 +30,11 @@ module Phlexi
         def checked?
           field.dom.value == @checked_value
         end
+
+        def normalize_input(...)
+          input_value = super
+          (input_value == @checked_value) ? input_value : nil
+        end
       end
     end
   end

data/lib/phlexi/form/components/select.rb

@@ -4,11 +4,14 @@ module Phlexi
   module Form
     module Components
       class Select < Base
+        include Concerns::HandlesInput
+        include Concerns::HandlesArrayInput
         include Concerns::HasOptions
 
-        def view_template(&block)
+        def view_template
+          input(type: :hidden, name: attributes[:name], value: "", autocomplete: "off", hidden: true) if include_hidden?
           select(**attributes) do
-            blank_option { blank_option_text } unless skip_blank_option?
+            blank_option { blank_option_text } if include_blank?
             options
           end
         end
@@ -35,7 +38,8 @@ module Phlexi
         end
 
         def build_select_attributes
-          @include_blank_option = attributes.delete(:include_blank_option)
+          @include_blank = attributes.delete(:include_blank)
+          @include_hidden = attributes.delete(:include_hidden)
 
           attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
           attributes[:required] = attributes.fetch(:required, field.required?)
@@ -48,8 +52,20 @@ module Phlexi
           field.placeholder
         end
 
-        def skip_blank_option?
-          @include_blank_option == false
+        def include_blank?
+          return true if @include_blank == true
+
+          @include_blank != false && !attributes[:multiple]
+        end
+
+        def include_hidden?
+          return false if @include_hidden == false
+
+          attributes[:multiple]
+        end
+
+        def normalize_input(input_value)
+          attributes[:multiple] ? normalize_array_input(input_value) : normalize_simple_input(input_value)
         end
       end
     end

data/lib/phlexi/form/components/submit_button.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class SubmitButton < Base
+        include Concerns::SubmitsForm
+
+        def view_template(&content)
+          content ||= proc { submit_type_label }
+          button(**attributes, &content)
+        end
+
+        protected
+
+        def build_attributes
+          root_key = field.dom.lineage.first.respond_to?(:dom_id) ? field.dom.lineage.first.dom_id : field.dom.lineage.first.key
+          attributes.fetch(:id) { attributes[:id] = "#{root_key}_submit_button" }
+          attributes[:class] = tokens(
+            component_name,
+            submit_type_value,
+            attributes[:class]
+          )
+
+          build_button_attributes
+        end
+
+        def build_button_attributes
+          formmethod = attributes[:formmethod]
+          if formmethod.present? && !/post|get/i.match?(formmethod) && !attributes.key?(:name) && !attributes.key?(:value)
+            attributes.merge! formmethod: :post, name: "_method", value: formmethod
+          end
+
+          attributes.fetch(:name) { attributes[:name] = "commit" }
+          attributes.fetch(:value) { attributes[:value] = submit_type_label }
+          attributes.fetch(:type) { attributes[:type] = :submit }
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/field_options/associations.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Associations
+        protected
+
+        def reflection
+          @reflection ||= find_association_reflection
+        end
+
+        def find_association_reflection
+          if object.class.respond_to?(:reflect_on_association)
+            object.class.reflect_on_association(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/field_options/autofocus.rb

@@ -8,7 +8,7 @@ module Phlexi
           options[:autofocus] == true
         end
 
-        def focus(autofocus = true)
+        def focused!(autofocus = true)
           options[:autofocus] = autofocus
           self
         end

data/lib/phlexi/form/field_options/collection.rb

@@ -16,20 +16,37 @@ module Phlexi
         private
 
         def infer_collection
-          if has_validators?
-            inclusion_validator = find_inclusion_validator
-            collection_value_from(inclusion_validator)
-          end
+          collection_value_from_association || collection_value_from_validator
         end
 
-        def collection_value_from(inclusion_validator)
-          if inclusion_validator
-            inclusion_validator.options[:in] || inclusion_validator.options[:within]
+        def collection_value_from_association
+          return unless reflection
+
+          relation = reflection.klass.all
+
+          if reflection.respond_to?(:scope) && reflection.scope
+            relation = if reflection.scope.parameters.any?
+              reflection.klass.instance_exec(object, &reflection.scope)
+            else
+              reflection.klass.instance_exec(&reflection.scope)
+            end
+          else
+            order = reflection.options[:order]
+            conditions = reflection.options[:conditions]
+            conditions = object.instance_exec(&conditions) if conditions.respond_to?(:call)
+
+            relation = relation.where(conditions) if relation.respond_to?(:where) && conditions.present?
+            relation = relation.order(order) if relation.respond_to?(:order)
           end
+
+          relation
         end
 
-        def find_inclusion_validator
-          find_validator(:inclusion)
+        def collection_value_from_validator
+          return unless has_validators?
+
+          inclusion_validator = find_validator(:inclusion)
+          inclusion_validator.options[:in] || inclusion_validator.options[:within] if inclusion_validator
         end
       end
     end

data/lib/phlexi/form/field_options/errors.rb

@@ -76,6 +76,16 @@ module Phlexi
         def has_custom_error?
           options[:error].is_a?(String)
         end
+
+        # Determines if the associated object is in a valid state
+        #
+        # An object is considered valid if it is persisted and has no errors.
+        #
+        # @return [Boolean] true if the object is persisted and has no errors, false otherwise
+        def object_valid?
+          object.respond_to?(:persisted?) && object.persisted? &&
+            object.respond_to?(:errors) && !object.errors.empty?
+        end
       end
     end
   end

data/lib/phlexi/form/field_options/{type.rb → inferred_types.rb}

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+
 module Phlexi
   module Form
     module FieldOptions
-      module Type
-        def db_type
-          @db_type ||= infer_db_type
+      module InferredTypes
+        def inferred_db_type
+          @inferred_db_type ||= infer_db_type
         end
 
-        def input_component
-          @input_component ||= infer_input_component
+        def inferred_input_component
+          @inferred_input_component ||= infer_input_component
         end
 
-        def input_type
-          @input_type ||= infer_input_type
+        def inferred_input_type
+          @inferred_input_type ||= infer_input_type(inferred_input_component)
         end
 
         private
@@ -23,7 +25,7 @@ module Phlexi
         def infer_input_component
           return :select unless collection.blank?
 
-          case db_type
+          case inferred_db_type
           when :text, :json, :jsonb, :hstore
             :textarea
           else
@@ -33,10 +35,8 @@ module Phlexi
 
         # this only applies when input_component is `:input`
         # resolves the type attribute of input components
-        def infer_input_type
-          return nil unless input_component == :input
-
-          case db_type
+        def infer_input_type(component)
+          case inferred_db_type
           when :string
             infer_string_input_type(key)
           when :integer, :float, :decimal

data/lib/phlexi/form/field_options/multiple.rb

@@ -16,7 +16,9 @@ module Phlexi
         private
 
         def calculate_multiple_field_value
+          return true if reflection&.macro == :has_many
           return true if multiple_field_array_attribute?
+
           check_multiple_field_from_validators
         end