phlexi-form 0.2.0

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    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/form/field_options/multiple.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    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 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/form/field_options/pattern.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    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/form/field_options/placeholder.rb

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

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

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

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Type
+        def db_type
+          @db_type ||= infer_db_type
+        end
+
+        def input_component
+          @input_component ||= infer_input_component
+        end
+
+        def input_type
+          @input_type ||= infer_input_type
+        end
+
+        private
+
+        # this returns the element type
+        # one of :input, :textarea, :select, :botton
+        def infer_input_component
+          return :select unless collection.blank?
+
+          case 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
+          return nil unless input_component == :input
+
+          case 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/form/field_options/validators.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module FieldOptions
+      module Validators
+        private
+
+        def has_validators?
+          @has_validators ||= object.class.respond_to?(:validators_on)
+        end
+
+        def attribute_validators
+          object.class.validators_on(key)
+        end
+
+        def reflection_validators
+          reflection ? object.class.validators_on(reflection.name) : []
+        end
+
+        def valid_validator?(validator)
+          !conditional_validators?(validator) && action_validator_match?(validator)
+        end
+
+        def conditional_validators?(validator)
+          validator.options.include?(:if) || validator.options.include?(:unless)
+        end
+
+        def action_validator_match?(validator)
+          return true unless validator.options.include?(:on)
+
+          case validator.options[:on]
+          when :save
+            true
+          when :create
+            !object.persisted?
+          when :update
+            object.persisted?
+          end
+        end
+
+        def find_validator(kind)
+          attribute_validators.find { |v| v.kind == kind && valid_validator?(v) } if has_validators?
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/option_mapper.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    # OptionMapper is responsible for converting a collection of objects into a hash of options
+    # suitable for form controls, such as `select > options`.
+    # Both values and labels are converted to strings.
+    #
+    # @example Basic usage
+    #   collection = [["First", 1], ["Second", 2]]
+    #   mapper = OptionMapper.new(collection)
+    #   mapper.each { |value, label| puts "#{value}: #{label}" }
+    #
+    # @example Using with ActiveRecord objects
+    #   users = User.all
+    #   mapper = OptionMapper.new(users)
+    #   mapper.each { |id, name| puts "#{id}: #{name}" }
+    #
+    # @example Array access with different value types
+    #   mapper = OptionMapper.new([["Integer", 1], ["String", "2"], ["Symbol", :three]])
+    #   puts mapper["1"]      # Output: "Integer"
+    #   puts mapper["2"]      # Output: "String"
+    #   puts mapper["three"]  # Output: "Symbol"
+    #
+    # @note This class is thread-safe as it doesn't maintain mutable state.
+    class OptionMapper
+      include Enumerable
+
+      # Initializes a new OptionMapper instance.
+      #
+      # @param collection [#call, #to_a] The collection to be mapped.
+      # @param label_method [Symbol, nil] The method to call on each object to get the label.
+      # @param value_method [Symbol, nil] The method to call on each object to get the value.
+      def initialize(collection, label_method: nil, value_method: nil)
+        @raw_collection = collection
+        @label_method = label_method
+        @value_method = value_method
+      end
+
+      # Iterates over the collection, yielding value-label pairs.
+      #
+      # @yieldparam value [String] The string value for the current item.
+      # @yieldparam label [String] The string label for the current item.
+      # @return [Enumerator] If no block is given.
+      def each(&)
+        collection.each(&)
+      end
+
+      # @return [Array<String>] An array of all labels in the collection.
+      def labels
+        collection.values
+      end
+
+      # @return [Array<String>] An array of all values in the collection.
+      def values
+        collection.keys
+      end
+
+      # Retrieves the label for a given value.
+      #
+      # @param value [#to_s] The value to look up.
+      # @return [String, nil] The label corresponding to the value, or nil if not found.
+      def [](value)
+        collection[value.to_s]
+      end
+
+      private
+
+      # @return [Hash<String, String>] The materialized collection as a hash of string value => string label.
+      def collection
+        @collection ||= materialize_collection(@raw_collection)
+      end
+
+      # Converts the raw collection into a materialized hash.
+      #
+      # @param collection [#call, #to_a] The collection to be materialized.
+      # @return [Hash<String, String>] The materialized collection as a hash of string value => string label.
+      # @raise [ArgumentError] If the collection cannot be materialized into an enumerable.
+      def materialize_collection(collection)
+        case collection
+        in Hash => hash
+          hash.transform_keys(&:to_s).transform_values(&:to_s)
+        in Array => arr
+          array_to_hash(arr)
+        in Range => range
+          range_to_hash(range)
+        in Proc => proc
+          materialize_collection(proc.call)
+        in Symbol
+          raise ArgumentError, "Symbol collections are not supported in this context"
+        in Set => set
+          array_to_hash(set.to_a)
+        else
+          array_to_hash(Array(collection))
+        end
+      rescue ArgumentError => e
+        # Rails.logger.warn("Unhandled inclusion collection type: #{e}")
+        {}
+      end
+
+      # Converts an array to a hash using detected or specified methods.
+      #
+      # @param array [Array] The array to convert.
+      # @return [Hash<String, String>] The resulting hash of string value => string label.
+      def array_to_hash(array)
+        sample = array.first || array.last
+        methods = detect_methods_for_sample(sample)
+
+        array.each_with_object({}) do |item, hash|
+          value = item.public_send(methods[:value]).to_s
+          label = item.public_send(methods[:label]).to_s
+          hash[value] = label
+        end
+      end
+
+      # Converts a range to a hash.
+      #
+      # @param range [Range] The range to convert.
+      # @return [Hash<String, String>] The range converted to a hash of string value => string label.
+      # @raise [ArgumentError] If the range is unbounded.
+      def range_to_hash(range)
+        raise ArgumentError, "Cannot safely materialize an unbounded range" if range.begin.nil? || range.end.nil?
+
+        range.each_with_object({}) { |value, hash| hash[value.to_s] = value.to_s }
+      end
+
+      # Detects suitable methods for label and value from a sample object.
+      #
+      # @param sample [Object] A sample object from the collection.
+      # @return [Hash{Symbol => Symbol}] A hash containing :label and :value keys with corresponding method names.
+      def detect_methods_for_sample(sample)
+        case sample
+        when Array
+          {value: :last, label: :first}
+        else
+          {
+            value: @value_method || collection_value_methods.find { |m| sample.respond_to?(m) },
+            label: @label_method || collection_label_methods.find { |m| sample.respond_to?(m) }
+          }
+        end
+      end
+
+      # @return [Array<Symbol>] An array of method names to try for collection values.
+      def collection_value_methods
+        @collection_value_methods ||= %i[to_param id to_s].freeze
+      end
+
+      # @return [Array<Symbol>] An array of method names to try for collection labels.
+      def collection_label_methods
+        @collection_label_methods ||= %i[to_label name title to_s].freeze
+      end
+    end
+  end
+end

data/lib/phlexi/form/structure/dom.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Structure
+      # Generates DOM IDs, names, etc. for a Field, Namespace, or Node based on
+      # norms that were established by Rails. These can be used outsidef or Rails in
+      # other Ruby web frameworks since it has now dependencies on Rails.
+      class DOM
+        def initialize(field:)
+          @field = field
+        end
+
+        # Converts the value of the field to a String, which is required to work
+        # with Phlex. Assumes that `Object#to_s` emits a format suitable for the web form.
+        def value
+          @field.value.to_s
+        end
+
+        # Walks from the current node to the parent node, grabs the names, and seperates
+        # them with a `_` for a DOM ID. One limitation of this approach is if multiple forms
+        # exist on the same page, the ID may be duplicate.
+        def id
+          lineage.map(&:key).join("_")
+        end
+
+        # The `name` attribute of a node, which is influenced by Rails (not sure where Rails got
+        # it from). All node names, except the parent node, are wrapped in a `[]` and collections
+        # are left empty. For example, `user[addresses][][street]` would be created for a form with
+        # data shaped like `{user: {addresses: [{street: "Sesame Street"}]}}`.
+        def name
+          root, *names = keys
+          names.map { |name| "[#{name}]" }.unshift(root).join
+        end
+
+        # Emit the id, name, and value in an HTML tag-ish that doesnt have an element.
+        def inspect
+          "<id=#{id.inspect} name=#{name.inspect} value=#{value.inspect}/>"
+        end
+
+        private
+
+        def keys
+          lineage.map do |node|
+            # If the parent of a field is a field, the name should be nil.
+            node.key unless node.parent.is_a? FieldBuilder
+          end
+        end
+
+        # One-liner way of walking from the current node all the way up to the parent.
+        def lineage
+          Enumerator.produce(@field, &:parent).take_while(&:itself).reverse
+        end
+      end
+    end
+  end
+end