phlexi-display 0.0.1

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

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

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

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

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

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

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

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module FieldOptions
+      module MinMax
+        def min(min_value = nil)
+          if min_value.nil?
+            options[:min] = options.fetch(:min) { calculate_min }
+          else
+            options[:min] = min_value
+            self
+          end
+        end
+
+        def max(max_value = nil)
+          if max_value.nil?
+            options[:max] = options.fetch(:max) { calculate_max }
+          else
+            options[:max] = max_value
+            self
+          end
+        end
+
+        def step
+          1 if min || max
+        end
+
+        private
+
+        def calculate_min
+          if (numericality_validator = find_numericality_validator)
+            get_min_from_validator(numericality_validator)
+          end
+        end
+
+        def calculate_max
+          if (numericality_validator = find_numericality_validator)
+            get_max_from_validator(numericality_validator)
+          end
+        end
+
+        def find_numericality_validator
+          find_validator(:numericality)
+        end
+
+        def get_min_from_validator(validator)
+          options = validator.options
+          min = if options.key?(:greater_than)
+            {value: options[:greater_than], exclusive: true}
+          elsif options.key?(:greater_than_or_equal_to)
+            {value: options[:greater_than_or_equal_to], exclusive: false}
+          end
+          evaluate_and_adjust_min(min)
+        end
+
+        def get_max_from_validator(validator)
+          options = validator.options
+          max = if options.key?(:less_than)
+            {value: options[:less_than], exclusive: true}
+          elsif options.key?(:less_than_or_equal_to)
+            {value: options[:less_than_or_equal_to], exclusive: false}
+          end
+          evaluate_and_adjust_max(max)
+        end
+
+        def evaluate_and_adjust_min(min)
+          return nil unless min
+
+          value = evaluate_numericality_validator_option(min[:value])
+          min[:exclusive] ? value + 1 : value
+        end
+
+        def evaluate_and_adjust_max(max)
+          return nil unless max
+
+          value = evaluate_numericality_validator_option(max[:value])
+          max[:exclusive] ? value - 1 : value
+        end
+
+        def evaluate_numericality_validator_option(option)
+          case option
+          when Proc
+            option.arity.zero? ? option.call : option.call(object)
+          else
+            option
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module FieldOptions
+      module Multiple
+        def multiple?
+          options[:multiple] = options.fetch(:multiple) { calculate_multiple_field_value }
+        end
+
+        def multiple!(multiple = true)
+          options[:multiple] = multiple
+          self
+        end
+
+        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
+
+        def multiple_field_array_attribute?
+          return false unless object.class.respond_to?(:columns_hash)
+
+          column = object.class.columns_hash[key.to_s]
+          return false unless column
+
+          case object.class.connection.adapter_name.downcase
+          when "postgresql"
+            column.array? || (column.type == :string && column.sql_type.include?("[]"))
+          end # || object.class.attribute_types[key.to_s].is_a?(ActiveRecord::Type::Serialized)
+        rescue
+          # Rails.logger.warn("Error checking multiple field array attribute: #{e.message}")
+          false
+        end
+
+        def check_multiple_field_from_validators
+          inclusion_validator = find_validator(:inclusion)
+          length_validator = find_validator(:length)
+
+          return false unless inclusion_validator || length_validator
+
+          check_multiple_field_inclusion_validator(inclusion_validator) ||
+            check_multiple_field_length_validator(length_validator)
+        end
+
+        def check_multiple_field_inclusion_validator(validator)
+          return false unless validator
+          in_option = validator.options[:in]
+          return false unless in_option.is_a?(Array)
+
+          validator.options[:multiple] == true || (multiple_field_array_attribute? && in_option.size > 1)
+        end
+
+        def check_multiple_field_length_validator(validator)
+          return false unless validator
+          validator.options[:maximum].to_i > 1 if validator.options[:maximum]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module FieldOptions
+      module Pattern
+        def pattern(pattern = nil)
+          if pattern.nil?
+            options[:pattern] = options.fetch(:pattern) { calculate_pattern }
+          else
+            options[:pattern] = pattern
+            self
+          end
+        end
+
+        private
+
+        def calculate_pattern
+          if (pattern_validator = find_pattern_validator) && (with = pattern_validator.options[:with])
+            evaluate_format_validator_option(with).source
+          end
+        end
+
+        def find_pattern_validator
+          find_validator(:format)
+        end
+
+        def evaluate_format_validator_option(option)
+          if option.respond_to?(:call)
+            option.call(object)
+          else
+            option
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module FieldOptions
+      module Placeholder
+        def placeholder(placeholder = nil)
+          if placeholder.nil?
+            options[:placeholder]
+          else
+            options[:placeholder] = placeholder
+            self
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Display
+    module FieldOptions
+      module Required
+        def required?
+          options[:required] = options.fetch(:required) { calculate_required }
+        end
+
+        def required!(required = true)
+          options[:required] = required
+          self
+        end
+
+        private
+
+        def calculate_required
+          if has_validators?
+            required_by_validators?
+          else
+            required_by_default?
+          end
+        end
+
+        def required_by_validators?
+          (attribute_validators + reflection_validators).any? { |v| v.kind == :presence && valid_validator?(v) }
+        end
+
+        def required_by_default?
+          # TODO: get this from configuration
+          false
+        end
+      end
+    end
+  end
+end