phlexi-display 0.0.1 → 0.0.3

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

@@ -1,41 +0,0 @@
-# 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

@@ -1,69 +0,0 @@
-# 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

@@ -1,41 +0,0 @@
-# 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

@@ -1,34 +0,0 @@
-# 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/field_options/associations.rb

@@ -1,21 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,54 +0,0 @@
-# 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

@@ -1,18 +0,0 @@
-# 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

@@ -1,92 +0,0 @@
-# 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

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

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

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require "bigdecimal"
-
-module Phlexi
-  module Display
-    module FieldOptions
-      module InferredTypes
-        def inferred_db_type
-          @inferred_db_type ||= infer_db_type
-        end
-
-        def inferred_input_component
-          @inferred_input_component ||= infer_input_component
-        end
-
-        def inferred_input_type
-          @inferred_input_type ||= infer_input_type(inferred_input_component)
-        end
-
-        private
-
-        # this returns the element type
-        # one of :input, :textarea, :select, :botton
-        def infer_input_component
-          return :select unless collection.blank?
-
-          case inferred_db_type
-          when :text, :json, :jsonb, :hstore
-            :textarea
-          else
-            :input
-          end
-        end
-
-        # this only applies when input_component is `:input`
-        # resolves the type attribute of input components
-        def infer_input_type(component)
-          case inferred_db_type
-          when :string
-            infer_string_input_type(key)
-          when :integer, :float, :decimal
-            :number
-          when :date
-            :date
-          when :datetime
-            :datetime
-          when :time
-            :time
-          when :boolean
-            :checkbox
-          else
-            :text
-          end
-        end
-
-        def infer_db_type
-          if object.class.respond_to?(:columns_hash)
-            # ActiveRecord object
-            column = object.class.columns_hash[key.to_s]
-            return column.type if column
-          end
-
-          if object.class.respond_to?(:attribute_types)
-            # ActiveModel::Attributes
-            custom_type = object.class.attribute_types[key.to_s]
-            return custom_type.type if custom_type
-          end
-
-          # Check if object responds to the key
-          if object.respond_to?(key)
-            # Fallback to inferring type from the value
-            return infer_db_type_from_value(object.send(key))
-          end
-
-          # Default to string if we can't determine the type
-          :string
-        end
-
-        def infer_db_type_from_value(value)
-          case value
-          when Integer
-            :integer
-          when Float, BigDecimal
-            :float
-          when TrueClass, FalseClass
-            :boolean
-          when Date
-            :date
-          when Time, DateTime
-            :datetime
-          else
-            :string
-          end
-        end
-
-        def infer_string_input_type(key)
-          key = key.to_s.downcase
-
-          return :password if is_password_field?
-
-          custom_type = custom_string_input_type(key)
-          return custom_type if custom_type
-
-          if has_validators?
-            infer_string_input_type_from_validations
-          else
-            :text
-          end
-        end
-
-        def custom_string_input_type(key)
-          custom_mappings = {
-            /url$|^link|^site/ => :url,
-            /^email/ => :email,
-            /^search/ => :search,
-            /phone|tel(ephone)?/ => :tel,
-            /^time/ => :time,
-            /^date/ => :date,
-            /^number|_count$|_amount$/ => :number,
-            /^color/ => :color
-          }
-
-          custom_mappings.each do |pattern, type|
-            return type if key.match?(pattern)
-          end
-
-          nil
-        end
-
-        def infer_string_input_type_from_validations
-          if attribute_validators.find { |v| v.kind == :numericality }
-            :number
-          elsif attribute_validators.find { |v| v.kind == :format && v.options[:with] == URI::MailTo::EMAIL_REGEXP }
-            :email
-          else
-            :text
-          end
-        end
-
-        def is_password_field?
-          key = self.key.to_s.downcase
-
-          exact_matches = ["password"]
-          prefixes = ["encrypted_"]
-          suffixes = ["_password", "_digest", "_hash"]
-
-          exact_matches.include?(key) ||
-            prefixes.any? { |prefix| key.start_with?(prefix) } ||
-            suffixes.any? { |suffix| key.end_with?(suffix) }
-        end
-      end
-    end
-  end
-end

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

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

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