phlexi-form 0.3.0.rc1 → 0.4.0

data/lib/phlexi/form/builder.rb

@@ -0,0 +1,297 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    # Builder class is responsible for building form fields with various options and components.
+    class Builder < Phlexi::Field::Builder
+      include Phlexi::Form::HTML::Behaviour
+      include Options::Validators
+      include Options::InferredTypes
+      include Options::Errors
+      include Options::Collection
+      include Options::Hints
+      include Options::Required
+      include Options::Autofocus
+      include Options::Disabled
+      include Options::Readonly
+      include Options::Length
+      include Options::Max
+      include Options::Min
+      include Options::Pattern
+      include Options::Limit
+      include Options::Step
+
+      class FieldCollection < Phlexi::Form::Structure::FieldCollection; end
+
+      attr_reader :input_attributes
+
+      # Initializes a new Builder instance.
+      #
+      # @param key [Symbol, String] The key for the field.
+      # @param parent [Structure::Namespace] The parent object.
+      # @param object [Object, nil] The associated object.
+      # @param value [Object] The initial value for the field.
+      # @param input_attributes [Hash] Default attributes to apply to input fields.
+      # @param options [Hash] Additional options for the field.
+      def initialize(*, input_attributes: {}, **)
+        super(*, **)
+
+        @input_attributes = input_attributes
+      end
+
+      # Creates an input tag for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the input.
+      # @return [Components::Input] The input component.
+      def input_tag(**, &)
+        create_component(Components::Input, :input, **, &)
+      end
+
+      def string_tag(**, &)
+        input_tag(type: :text, theme: :string, **, &)
+      end
+
+      def number_tag(**, &)
+        input_tag(type: :number, theme: :number, **, &)
+      end
+
+      def date_tag(**, &)
+        input_tag(type: :date, theme: :date, **, &)
+      end
+
+      def time_tag(**, &)
+        input_tag(type: :time, theme: :time, **, &)
+      end
+
+      def datetime_local_tag(**, &)
+        input_tag(type: :"datetime-local", theme: :datetime, **, &)
+      end
+      alias_method :datetime_tag, :datetime_local_tag
+
+      def email_tag(**, &)
+        input_tag(type: :email, theme: :email, **, &)
+      end
+
+      def password_tag(**, &)
+        input_tag(type: :password, theme: :password, **, &)
+      end
+
+      def phone_tag(**, &)
+        input_tag(type: :tel, theme: :phone, **, &)
+      end
+
+      def color_tag(**, &)
+        input_tag(type: :color, theme: :color, **, &)
+      end
+
+      def url_tag(**, &)
+        input_tag(type: :url, theme: :url, **, &)
+      end
+
+      def search_tag(**, &)
+        input_tag(type: :search, theme: :search, **, &)
+      end
+
+      # Creates a checkbox tag for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the checkbox.
+      # @return [Components::Checkbox] The checkbox component.
+      def checkbox_tag(**, &)
+        create_component(Components::Checkbox, :checkbox, **, &)
+      end
+
+      def boolean_tag(**, &)
+        checkbox_tag(**, theme: :boolean, &)
+      end
+
+      def file_input_tag(**, &)
+        create_component(Components::FileInput, :file, **, &)
+      end
+      alias_method :file_tag, :file_input_tag
+
+      # Creates collection checkboxes for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the collection checkboxes.
+      # @yield [block] The block to be executed for each checkbox.
+      # @return [Components::CollectionCheckboxes] The collection checkboxes component.
+      def collection_checkboxes_tag(**, &)
+        create_component(Components::CollectionCheckboxes, :collection_checkboxes, **, &)
+      end
+
+      # Creates a radio button tag for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the radio button.
+      # @return [Components::RadioButton] The radio button component.
+      def radio_button_tag(**, &)
+        create_component(Components::RadioButton, :radio, **, &)
+      end
+
+      # Creates collection radio buttons for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the collection radio buttons.
+      # @yield [block] The block to be executed for each radio button.
+      # @return [Components::CollectionRadioButtons] The collection radio buttons component.
+      def collection_radio_buttons_tag(**, &)
+        create_component(Components::CollectionRadioButtons, :collection_radio_buttons, **, &)
+      end
+
+      # Creates a textarea tag for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the textarea.
+      # @return [Components::Textarea] The textarea component.
+      def textarea_tag(**, &)
+        create_component(Components::Textarea, :textarea, **, &)
+      end
+      alias_method :text_tag, :textarea_tag
+
+      def hstore_tag(**, &)
+        @value = @value.to_s.tr("{}", "")
+        textarea_tag(**, theme: :hstore, &)
+      end
+
+      # Creates a select tag for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the select.
+      # @return [Components::Select] The select component.
+      def select_tag(**, &)
+        create_component(Components::Select, :select, **, &)
+      end
+
+      def belongs_to_tag(**options, &)
+        options.fetch(:input_param) {
+          options[:input_param] = if association_reflection.respond_to?(:options) && association_reflection.options[:foreign_key]
+            association_reflection.options[:foreign_key]
+          else
+            :"#{association_reflection.name}_id"
+          end
+        }
+        select_tag(**options, &)
+      end
+
+      def polymorphic_belongs_to_tag(**, &)
+        # TODO: this requires a grouped_select component
+        # see: Plutonium::Core::Fields::Inputs::PolymorphicBelongsToAssociationInput
+        raise NotImplementedError, "polymorphic belongs_to associations are not YET supported"
+      end
+
+      def has_one_tag(**, &)
+        raise NotImplementedError, "has_one associations are NOT supported"
+      end
+
+      def has_many_tag(**options, &)
+        options.fetch(:input_param) {
+          options[:input_param] = :"#{association_reflection.name.to_s.singularize}_ids"
+        }
+
+        select_tag(**options, &)
+      end
+
+      def input_array_tag(**, &)
+        create_component(Components::InputArray, :array, **, &)
+      end
+
+      # Creates a label tag for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the label.
+      # @return [Components::Label] The label component.
+      def label_tag(**, &)
+        create_component(Components::Label, :label, **, &)
+      end
+
+      # Creates a hint tag for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the hint.
+      # @return [Components::Hint] The hint component.
+      def hint_tag(**, &)
+        create_component(Components::Hint, :hint, **, &)
+      end
+
+      # Creates an error tag for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the error.
+      # @return [Components::Error] The error component.
+      def error_tag(**, &)
+        create_component(Components::Error, :error, **, &)
+      end
+
+      # Creates a full error tag for the field.
+      #
+      # @param attributes [Hash] Additional attributes for the full error.
+      # @return [Components::FullError] The full error component.
+      def full_error_tag(**, &)
+        create_component(Components::FullError, :full_error, **, &)
+      end
+
+      # Wraps the field with additional markup.
+      #
+      # @param inner [Hash] Attributes for the inner wrapper.
+      # @param attributes [Hash] Additional attributes for the wrapper.
+      # @yield [block] The block to be executed within the wrapper.
+      # @return [Components::Wrapper] The wrapper component.
+      def wrapped(inner: {}, **attributes, &)
+        attributes = apply_component_theme(attributes, :wrapper)
+        inner = apply_component_theme(inner, :inner_wrapper)
+        Components::Wrapper.new(self, inner: inner, **attributes, &)
+      end
+
+      # Creates a submit button
+      #
+      # @param attributes [Hash] Additional attributes for the submit.
+      # @return [Components::SubmitButton] The submit button component.
+      def submit_button_tag(**, &)
+        create_component(Components::SubmitButton, :submit_button, **, &)
+      end
+
+      def extract_input(params)
+        raise "field##{dom.name} did not define an input component" unless @field_input_extractor
+
+        @field_input_extractor.extract_input(params)
+      end
+
+      protected
+
+      def create_component(component_class, theme_key, **attributes, &)
+        attributes = mix(input_attributes, attributes) if component_class.include?(Phlexi::Form::Components::Concerns::HandlesInput)
+        component = component_class.new(self, **apply_component_theme(attributes, theme_key), &)
+        if component_class.include?(Components::Concerns::ExtractsInput)
+          raise "input component already defined: #{@field_input_extractor.inspect}" if @field_input_extractor
+
+          @field_input_extractor = component
+        end
+
+        component
+      end
+
+      def apply_component_theme(attributes, theme_key)
+        return attributes if attributes.key?(:class!)
+
+        theme_key = attributes.delete(:theme) || theme_key
+        mix({class: themed(theme_key, self)}, attributes)
+      end
+
+      def determine_initial_value(value)
+        return value unless value == NIL_VALUE
+
+        determine_value_from_association || super
+      end
+
+      def determine_value_from_object
+        object.respond_to?(key) ? object.public_send(key) : nil
+      end
+
+      def determine_value_from_association
+        return nil unless association_reflection.present?
+
+        value = object.public_send(key)
+        case association_reflection.macro
+        when :has_many, :has_and_belongs_to_many
+          value&.map { |v| v.public_send(association_reflection.klass.primary_key) }
+        when :belongs_to, :has_one
+          value&.public_send(association_reflection.klass.primary_key)
+        else
+          raise ArgumentError, "Unsupported association type: #{association_reflection.macro}"
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module Phlexi
   module Form
     module Components
-      class Base < COMPONENT_BASE
+      class Base < Phlexi::Form::HTML
         attr_reader :field, :attributes
 
         def initialize(field, **attributes)
@@ -23,15 +23,15 @@ module Phlexi
         def append_attribute_classes
           return if attributes[:class] == false
 
-          attributes[:class] = tokens(
+          default_classes = tokens(
             component_name,
-            attributes[:class],
             -> { attributes[:required] } => "required",
             -> { !attributes[:required] } => "optional",
             -> { field.has_errors? } => "invalid",
             -> { attributes[:readonly] } => "readonly",
             -> { attributes[:disabled] } => "disabled"
           )
+          attributes[:class] = tokens(default_classes, attributes[:class])
         end
 
         def component_name

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

@@ -10,7 +10,7 @@ module Phlexi
 
         def view_template
           div(**attributes.slice(:id, :class)) do
-            field.multi(option_mapper.values) do |builder|
+            field.repeated(option_mapper.values) do |builder|
               render builder.hidden_field_tag if builder.index == 0
 
               field = builder.field(

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

@@ -9,7 +9,7 @@ module Phlexi
 
         def view_template
           div(**attributes.slice(:id, :class)) do
-            field.multi(option_mapper.values) do |builder|
+            field.repeated(option_mapper.values) do |builder|
               render builder.hidden_field_tag if builder.index == 0
 
               field = builder.field(

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      module Concerns
+        module ExtractsInput
+          # Collects parameters matching the input field's param key.
+          #
+          # @param params [Hash] the parameters to collect from.
+          # @return [Hash] the collected parameters.
+          def extract_input(params)
+            # # Handles multi parameter attributes
+            # # https://www.cookieshq.co.uk/posts/rails-spelunking-date-select
+            # # https://www.cookieshq.co.uk/posts/multiparameter-attributes
+
+            # # Matches
+            # # - parameter
+            # # - parameter(1)
+            # # - parameter(2)
+            # # - parameter(1i)
+            # # - parameter(2f)
+            # regex = /^#{param}(\(\d+[if]?\))?$/
+            # keys = params.select { |key, _| regex.match?(key) }.keys
+            # params.slice(*keys)
+
+            params ||= {}
+            {input_param => normalize_input(params[field.key])}
+          end
+
+          protected
+
+          def build_attributes
+            super
+            @input_param = attributes.delete(:input_param) || field.key
+          end
+
+          def input_param
+            @input_param
+          end
+
+          def normalize_input(input_value)
+            normalize_simple_input(input_value)
+          end
+
+          def normalize_simple_input(input_value)
+            input_value.to_s.presence
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,46 +5,16 @@ module Phlexi
     module Components
       module Concerns
         module HandlesInput
-          # Collects parameters matching the input field's param key.
-          #
-          # @param params [Hash] the parameters to collect from.
-          # @return [Hash] the collected parameters.
-          def extract_input(params)
-            # # Handles multi parameter attributes
-            # # https://www.cookieshq.co.uk/posts/rails-spelunking-date-select
-            # # https://www.cookieshq.co.uk/posts/multiparameter-attributes
-
-            # # Matches
-            # # - parameter
-            # # - parameter(1)
-            # # - parameter(2)
-            # # - parameter(1i)
-            # # - parameter(2f)
-            # regex = /^#{param}(\(\d+[if]?\))?$/
-            # keys = params.select { |key, _| regex.match?(key) }.keys
-            # params.slice(*keys)
-
-            params ||= {}
-            {input_param => normalize_input(params[field.key])}
-          end
+          include Phlexi::Form::Components::Concerns::ExtractsInput
 
           protected
 
           def build_attributes
             super
-            @input_param = attributes.delete(:input_param) || field.key
-          end
-
-          def input_param
-            @input_param
-          end
-
-          def normalize_input(input_value)
-            normalize_simple_input(input_value)
-          end
 
-          def normalize_simple_input(input_value)
-            input_value.to_s.presence
+            # 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
           end
         end
       end

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

@@ -5,6 +5,14 @@ module Phlexi
     module Components
       module Concerns
         module SubmitsForm
+          include Phlexi::Form::Components::Concerns::ExtractsInput
+
+          def extract_input(params)
+            {}
+          end
+
+          protected
+
           def submit_type_value
             if field.object.respond_to?(:persisted?)
               field.object.persisted? ? :update : :create

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

@@ -13,7 +13,7 @@ module Phlexi
         private
 
         def render?
-          field.show_errors? && field.has_errors?
+          field.show_errors?
         end
       end
     end

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

@@ -14,6 +14,7 @@ module Phlexi
         def build_input_attributes
           attributes[:type] = :file
           super
+          # ensure we are always setting it to false
           attributes[:value] = false
         end
 

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

@@ -13,7 +13,7 @@ module Phlexi
         private
 
         def render?
-          field.hint.present? && (!field.show_errors? || !field.has_errors?)
+          field.show_hint?
         end
       end
     end

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+
 module Phlexi
   module Form
     module Components
@@ -15,17 +17,13 @@ module Phlexi
         def build_attributes
           super
 
-          # 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
 
           build_input_attributes
         end
 
         def build_input_attributes
-          attributes.fetch(:type) { attributes[:type] = field.inferred_input_type }
+          attributes.fetch(:type) { attributes[:type] = field.inferred_string_field_type }
           attributes.fetch(:disabled) { attributes[:disabled] = field.disabled? }
 
           case attributes[:type]
@@ -52,12 +50,24 @@ module Phlexi
             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
+          when :date, :time, :"datetime-local"
             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 }
+
+            # TODO: Investigate if this is Timezone complaint
+            if field.value.respond_to?(:strftime)
+              attributes[:value] = case attributes[:type]
+              when :date
+                field.value.strftime("%Y-%m-%d")
+              when :time
+                field.value.strftime("%H:%M:%S")
+              when :"datetime-local"
+                field.value.strftime("%Y-%m-%dT%H:%M:%S")
+              end
+            end
           when :color
             attributes.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
           when :range

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

@@ -9,7 +9,7 @@ module Phlexi
 
         def view_template
           div(**attributes.slice(:id, :class)) do
-            field.multi(values.length) do |builder|
+            field.repeated(values.length) do |builder|
               render builder.hidden_field_tag if builder.index == 0
 
               field = builder.field(

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

@@ -31,9 +31,6 @@ module Phlexi
         def build_attributes
           super
 
-          attributes[:id] = field.dom.id
-          attributes[:name] = field.dom.name
-
           build_select_attributes
         end
 
@@ -46,6 +43,10 @@ module Phlexi
           attributes[:disabled] = attributes.fetch(:disabled, field.disabled?)
           attributes[:multiple] = attributes.fetch(:multiple, field.multiple?)
           attributes[:size] = attributes.fetch(:size, field.limit)
+
+          if attributes[:multiple]
+            attributes[:name] = "#{attributes[:name].sub(/\[\]$/, "")}[]"
+          end
         end
 
         def blank_option_text

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

@@ -4,6 +4,8 @@ module Phlexi
   module Form
     module Components
       class Textarea < Base
+        include Concerns::HandlesInput
+
         def view_template
           textarea(**attributes) { field.dom.value }
         end
@@ -13,9 +15,6 @@ module Phlexi
         def build_attributes
           super
 
-          attributes[:id] = field.dom.id
-          attributes[:name] = field.dom.name
-
           build_textarea_attributes
         end
 

data/lib/phlexi/form/html.rb

@@ -0,0 +1,18 @@
+module Phlexi
+  module Form
+    class HTML < (defined?(::ApplicationComponent) ? ::ApplicationComponent : Phlex::HTML)
+      module Behaviour
+        protected
+
+        def themed(component, field)
+          base_theme = Phlexi::Form::Theme.instance.resolve_theme(component)
+          validity_theme = Phlexi::Form::Theme.instance.resolve_validity_theme(component, field)
+
+          tokens(base_theme, validity_theme)
+        end
+      end
+
+      include Behaviour
+    end
+  end
+end

data/lib/phlexi/form/{field_options → options}/autofocus.rb

@@ -2,7 +2,7 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Autofocus
         def focused?
           options[:autofocus] == true

data/lib/phlexi/form/{field_options → options}/collection.rb

@@ -2,11 +2,11 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Collection
         def collection(collection = nil)
           if collection.nil?
-            options[:collection] = options.fetch(:collection) { infer_collection }
+            options.fetch(:collection) { options[:collection] = infer_collection }
           else
             options[:collection] = collection
             self
@@ -16,23 +16,27 @@ module Phlexi
         private
 
         def infer_collection
+          if object.class.respond_to?(:defined_enums)
+            return object.class.defined_enums.fetch(key.to_s).keys if object.class.defined_enums.key?(key.to_s)
+          end
+
           collection_value_from_association || collection_value_from_validator
         end
 
         def collection_value_from_association
-          return unless reflection
+          return unless association_reflection
 
-          relation = reflection.klass.all
+          relation = association_reflection.klass.all
 
-          if reflection.respond_to?(:scope) && reflection.scope
-            relation = if reflection.scope.parameters.any?
-              reflection.klass.instance_exec(object, &reflection.scope)
+          if association_reflection.respond_to?(:scope) && association_reflection.scope
+            relation = if association_reflection.scope.parameters.any?
+              association_reflection.klass.instance_exec(object, &association_reflection.scope)
             else
-              reflection.klass.instance_exec(&reflection.scope)
+              association_reflection.klass.instance_exec(&association_reflection.scope)
             end
           else
-            order = reflection.options[:order]
-            conditions = reflection.options[:conditions]
+            order = association_reflection.options[:order]
+            conditions = association_reflection.options[:conditions]
             conditions = object.instance_exec(&conditions) if conditions.respond_to?(:call)
 
             relation = relation.where(conditions) if relation.respond_to?(:where) && conditions.present?

data/lib/phlexi/form/{field_options → options}/disabled.rb

@@ -2,7 +2,7 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Disabled
         def disabled?
           options[:disabled] == true