phlexi-display 0.0.1

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module Components
+      class Error < Base
+        def view_template
+          p(**attributes) do
+            field.error
+          end
+        end
+
+        private
+
+        def render?
+          field.show_errors? && field.has_errors?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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/display/components/full_error.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module Components
+      class FullError < Base
+        def view_template
+          p(**attributes) do
+            field.full_error
+          end
+        end
+
+        private
+
+        def render?
+          field.show_errors? && field.has_errors?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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/display/components/input.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module Components
+      class Input < Base
+        include Concerns::HandlesInput
+
+        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.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.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.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.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
+            attributes.fetch(:required) { attributes[:required] = field.required? }
+          when :file
+            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.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.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
+          when :range
+            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(/\[\]$/, "")}[]"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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/display/components/label.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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.fetch(:for) { attributes[:for] = field.dom.id }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module Components
+      class RadioButton < Input
+        def view_template
+          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
+          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
+
+        def normalize_input(...)
+          input_value = super
+          (input_value == @checked_value) ? input_value : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module Components
+      class Select < Base
+        include Concerns::HandlesInput
+        include Concerns::HandlesArrayInput
+        include Concerns::HasOptions
+
+        def view_template
+          PUI::Select.new
+        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 = attributes.delete(:include_blank)
+          @include_hidden = attributes.delete(:include_hidden)
+
+          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 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
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module Components
+      class SubmitButton < Base
+        include Concerns::SubmitsDisplay
+
+        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/display/components/textarea.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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/display/components/wrapper.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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/display/field_options/associations.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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/display/field_options/autofocus.rb

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

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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
+          collection_value_from_association || collection_value_from_validator
+        end
+
+        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 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
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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/display/field_options/errors.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    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
+
+        # 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
+end