phlexi-form 0.2.0

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class Hint < Base
+        def view_template
+          p(**attributes) do
+            field.hint
+          end
+        end
+
+        private
+
+        def render?
+          field.hint.present? && (!field.show_errors? || !field.has_errors?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class Input < Base
+        def view_template
+          input(**attributes)
+        end
+
+        protected
+
+        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[:type] = attributes.fetch(:type, field.input_type)
+          attributes[:disabled] = attributes.fetch(: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)
+          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)
+          when :checkbox, :radio
+            attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
+            attributes[:required] = attributes.fetch(: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)
+          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)
+          when :color
+            attributes[:autofocus] = attributes.fetch(: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)
+          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(/\[]$/, "")}[]"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class Label < Base
+        def view_template
+          label(**attributes) do
+            if field.required?
+              abbr(title: "required") { "*" }
+              whitespace
+            end
+            plain field.label
+          end
+        end
+
+        protected
+
+        def build_attributes
+          super
+          attributes[:for] ||= field.dom.id
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class RadioButton < Input
+        def view_template
+          input(**attributes, value: @checked_value)
+        end
+
+        protected
+
+        def build_input_attributes
+          attributes[:type] = :radio
+          super
+
+          @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[:value] = @checked_value
+          attributes[:checked] = attributes.fetch(:checked) { checked? }
+        end
+
+        def checked?
+          field.dom.value == @checked_value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class Select < Base
+        include Concerns::HasOptions
+
+        def view_template(&block)
+          select(**attributes) do
+            blank_option { blank_option_text } unless skip_blank_option?
+            options
+          end
+        end
+
+        protected
+
+        def options
+          option_mapper.each do |value, label|
+            option(selected: selected?(value), value: value) { label }
+          end
+        end
+
+        def blank_option(&)
+          option(selected: field.value.nil?, &)
+        end
+
+        def build_attributes
+          super
+
+          attributes[:id] = field.dom.id
+          attributes[:name] = field.dom.name
+
+          build_select_attributes
+        end
+
+        def build_select_attributes
+          @include_blank_option = attributes.delete(:include_blank_option)
+
+          attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
+          attributes[:required] = attributes.fetch(:required, field.required?)
+          attributes[:disabled] = attributes.fetch(:disabled, field.disabled?)
+          attributes[:multiple] = attributes.fetch(:multiple, field.multiple?)
+          attributes[:size] = attributes.fetch(:size, field.limit)
+        end
+
+        def blank_option_text
+          field.placeholder
+        end
+
+        def skip_blank_option?
+          @include_blank_option == false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class Textarea < Base
+        def view_template
+          textarea(**attributes) { field.dom.value }
+        end
+
+        protected
+
+        def build_attributes
+          super
+
+          attributes[:id] = field.dom.id
+          attributes[:name] = field.dom.name
+
+          build_textarea_attributes
+        end
+
+        def build_textarea_attributes
+          attributes[:placeholder] = attributes.fetch(:placeholder, field.placeholder)
+          attributes[:autofocus] = attributes.fetch(:autofocus, field.focused?)
+          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[:disabled] = attributes.fetch(:disabled, field.disabled?)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Components
+      class Wrapper < Base
+        attr_reader :inner_attributes
+
+        def view_template
+          div(**attributes) do
+            render field.label_tag
+            div(**inner_attributes) do
+              yield field if block_given?
+              render field.full_error_tag
+              render field.hint_tag
+            end
+          end
+        end
+
+        protected
+
+        def build_attributes
+          super
+
+          @inner_attributes = attributes.delete(:inner) || {}
+          inner_attributes[:class] = tokens("inner-wrapper", inner_attributes[:class])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Autofocus
+        def focused?
+          options[:autofocus] == true
+        end
+
+        def focus(autofocus = true)
+          options[:autofocus] = autofocus
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Collection
+        def collection(collection = nil)
+          if collection.nil?
+            options[:collection] = options.fetch(:collection) { infer_collection }
+          else
+            options[:collection] = collection
+            self
+          end
+        end
+
+        private
+
+        def infer_collection
+          if has_validators?
+            inclusion_validator = find_inclusion_validator
+            collection_value_from(inclusion_validator)
+          end
+        end
+
+        def collection_value_from(inclusion_validator)
+          if inclusion_validator
+            inclusion_validator.options[:in] || inclusion_validator.options[:within]
+          end
+        end
+
+        def find_inclusion_validator
+          find_validator(:inclusion)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Disabled
+        def disabled?
+          options[:disabled] == true
+        end
+
+        def disabled!(disabled = true)
+          options[:disabled] = disabled
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Errors
+        def custom_error(error)
+          options[:error] = error
+          self
+        end
+
+        def error
+          error_text if has_errors?
+        end
+
+        def full_error
+          full_error_text if has_errors?
+        end
+
+        def has_errors?
+          object_with_errors? || !object && has_custom_error?
+        end
+
+        def show_errors?
+          options[:error] != false
+        end
+
+        def valid?
+          !has_errors? && has_value?
+        end
+
+        protected
+
+        def error_text
+          text = has_custom_error? ? options[:error] : errors.send(error_method)
+
+          "#{options[:error_prefix]} #{text}".lstrip
+        end
+
+        def full_error_text
+          has_custom_error? ? options[:error] : full_errors.send(error_method)
+        end
+
+        def object_with_errors?
+          object&.respond_to?(:errors) && errors.present?
+        end
+
+        def error_method
+          options[:error_method] || :first
+        end
+
+        def errors
+          @errors ||= (errors_on_attribute + errors_on_association).compact
+        end
+
+        def full_errors
+          @full_errors ||= (full_errors_on_attribute + full_errors_on_association).compact
+        end
+
+        def errors_on_attribute
+          object.errors[key] || []
+        end
+
+        def full_errors_on_attribute
+          object.errors.full_messages_for(key)
+        end
+
+        def errors_on_association
+          reflection ? object.errors[reflection.name] : []
+        end
+
+        def full_errors_on_association
+          reflection ? object.errors.full_messages_for(reflection.name) : []
+        end
+
+        def has_custom_error?
+          options[:error].is_a?(String)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Hints
+        def hint(hint = nil)
+          if hint.nil?
+            options[:hint]
+          else
+            options[:hint] = hint
+            self
+          end
+        end
+
+        def has_hint?
+          options[:hint] != false && hint.present?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Labels
+        def label(label = nil)
+          if label.nil?
+            options[:label] = options.fetch(:label) { calculate_label }
+          else
+            options[:label] = label
+            self
+          end
+        end
+
+        private
+
+        def calculate_label
+          if object.class.respond_to?(:human_attribute_name)
+            object.class.human_attribute_name(key.to_s, {base: object})
+          else
+            key.to_s.humanize
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Length
+        def minlength(minlength = nil)
+          if minlength.nil?
+            options[:minlength] = options.fetch(:minlength) { calculate_minlength }
+          else
+            options[:minlength] = minlength
+            self
+          end
+        end
+
+        def maxlength(maxlength = nil)
+          if maxlength.nil?
+            options[:maxlength] = options.fetch(:maxlength) { calculate_maxlength }
+          else
+            options[:maxlength] = maxlength
+            self
+          end
+        end
+
+        private
+
+        def calculate_minlength
+          minimum_length_value_from(find_length_validator)
+        end
+
+        def minimum_length_value_from(length_validator)
+          if length_validator
+            length_validator.options[:is] || length_validator.options[:minimum]
+          end
+        end
+
+        def calculate_maxlength
+          maximum_length_value_from(find_length_validator)
+        end
+
+        def maximum_length_value_from(length_validator)
+          if length_validator
+            length_validator.options[:is] || length_validator.options[:maximum]
+          end
+        end
+
+        def find_length_validator
+          find_validator(:length)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Limit
+        def limit(limit = nil)
+          if limit.nil?
+            options[:limit] = options.fetch(:limit) { calculate_limit }
+          else
+            options[:limit] = limit
+            self
+          end
+        end
+
+        private
+
+        def calculate_limit
+          return unless multiple?
+
+          limit_from_validators = [
+            limit_from_length_validator,
+            limit_from_inclusion_validator
+          ].compact.min
+
+          limit_from_validators || limit_from_db_column
+        end
+
+        def limit_from_length_validator
+          length_validator = find_validator(:length)
+          return unless length_validator
+
+          length_validator.options[:maximum]
+        end
+
+        def limit_from_inclusion_validator
+          return unless has_validators?
+
+          inclusion_validator = find_validator(:inclusion)
+          return unless inclusion_validator
+
+          in_option = inclusion_validator.options[:in]
+          in_option.is_a?(Array) ? in_option.size : nil
+        end
+
+        def limit_from_db_column
+          return unless object.class.respond_to?(:columns_hash)
+
+          column = object.class.columns_hash[key.to_s]
+          return unless column
+
+          case object.class.connection.adapter_name.downcase
+          when "postgresql"
+            if column.array?
+              # Check if there's a limit on the array size
+              column.limit
+            elsif column.type == :string && column.sql_type.include?("[]")
+              # For string arrays, extract the limit if specified
+              column.sql_type.match(/\[(\d+)\]/)&.captures&.first&.to_i
+            end
+          end
+        end
+      end
+    end
+  end
+end