phlexi-form 0.3.0 → 0.4.0

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+
 module Phlexi
   module Form
     module Components
@@ -21,7 +23,7 @@ module Phlexi
         end
 
         def build_input_attributes
-          attributes.fetch(:type) { attributes[:type] = field.inferred_input_component_subtype }
+          attributes.fetch(:type) { attributes[:type] = field.inferred_string_field_type }
           attributes.fetch(:disabled) { attributes[:disabled] = field.disabled? }
 
           case attributes[:type]
@@ -48,12 +50,24 @@ module Phlexi
             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
+          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 }
+
+            # TODO: Investigate if this is Timezone complaint
+            if field.value.respond_to?(:strftime)
+              attributes[:value] = case attributes[:type]
+              when :date
+                field.value.strftime("%Y-%m-%d")
+              when :time
+                field.value.strftime("%H:%M:%S")
+              when :"datetime-local"
+                field.value.strftime("%Y-%m-%dT%H:%M:%S")
+              end
+            end
           when :color
             attributes.fetch(:autofocus) { attributes[:autofocus] = field.focused? }
           when :range

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

@@ -43,6 +43,10 @@ module Phlexi
           attributes[:disabled] = attributes.fetch(:disabled, field.disabled?)
           attributes[:multiple] = attributes.fetch(:multiple, field.multiple?)
           attributes[:size] = attributes.fetch(:size, field.limit)
+
+          if attributes[:multiple]
+            attributes[:name] = "#{attributes[:name].sub(/\[\]$/, "")}[]"
+          end
         end
 
         def blank_option_text

data/lib/phlexi/form/html.rb

@@ -0,0 +1,18 @@
+module Phlexi
+  module Form
+    class HTML < (defined?(::ApplicationComponent) ? ::ApplicationComponent : Phlex::HTML)
+      module Behaviour
+        protected
+
+        def themed(component, field)
+          base_theme = Phlexi::Form::Theme.instance.resolve_theme(component)
+          validity_theme = Phlexi::Form::Theme.instance.resolve_validity_theme(component, field)
+
+          tokens(base_theme, validity_theme)
+        end
+      end
+
+      include Behaviour
+    end
+  end
+end

data/lib/phlexi/form/{field_options → options}/autofocus.rb

@@ -2,7 +2,7 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Autofocus
         def focused?
           options[:autofocus] == true

data/lib/phlexi/form/{field_options → options}/collection.rb

@@ -2,11 +2,11 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Collection
         def collection(collection = nil)
           if collection.nil?
-            options[:collection] = options.fetch(:collection) { infer_collection }
+            options.fetch(:collection) { options[:collection] = infer_collection }
           else
             options[:collection] = collection
             self
@@ -16,6 +16,10 @@ module Phlexi
         private
 
         def infer_collection
+          if object.class.respond_to?(:defined_enums)
+            return object.class.defined_enums.fetch(key.to_s).keys if object.class.defined_enums.key?(key.to_s)
+          end
+
           collection_value_from_association || collection_value_from_validator
         end
 

data/lib/phlexi/form/{field_options → options}/disabled.rb

@@ -2,7 +2,7 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Disabled
         def disabled?
           options[:disabled] == true

data/lib/phlexi/form/{field_options → options}/errors.rb

@@ -2,7 +2,7 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Errors
         def custom_error(error)
           options[:error] = error
@@ -33,6 +33,16 @@ module Phlexi
           !has_errors? && has_value?
         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
+
         protected
 
         def error_text
@@ -80,16 +90,6 @@ module Phlexi
         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

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Options
+      module Hints
+        def show_hint?
+          has_hint? && !show_errors?
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/options/inferred_types.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Options
+      module InferredTypes
+        private
+
+        def infer_field_component
+          case inferred_field_type
+          when :string, :text
+            infer_string_field_type || inferred_field_type
+          when :integer, :float, :decimal
+            :number
+          when :json, :jsonb
+            :text
+          when :enum
+            :select
+          when :association
+            association_reflection.polymorphic? ? :"polymorphic_#{association_reflection.macro}" : association_reflection.macro
+          when :attachment, :binary
+            :file
+          when :date, :time, :datetime, :boolean, :hstore
+            inferred_field_type
+          else
+            :string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/{field_options → options}/length.rb

@@ -2,11 +2,11 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Length
         def minlength(minlength = nil)
           if minlength.nil?
-            options[:minlength] = options.fetch(:minlength) { calculate_minlength }
+            options.fetch(:minlength) { options[:minlength] = calculate_minlength }
           else
             options[:minlength] = minlength
             self
@@ -15,7 +15,7 @@ module Phlexi
 
         def maxlength(maxlength = nil)
           if maxlength.nil?
-            options[:maxlength] = options.fetch(:maxlength) { calculate_maxlength }
+            options.fetch(:maxlength) { options[:maxlength] = calculate_maxlength }
           else
             options[:maxlength] = maxlength
             self

data/lib/phlexi/form/{field_options → options}/limit.rb

@@ -2,11 +2,11 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Limit
         def limit(limit = nil)
           if limit.nil?
-            options[:limit] = options.fetch(:limit) { calculate_limit }
+            options.fetch(:limit) { options[:limit] = calculate_limit }
           else
             options[:limit] = limit
             self

data/lib/phlexi/form/options/max.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Options
+      module Max
+        def max(max_value = nil)
+          if max_value.nil?
+            options.fetch(:max) { options[:max] = calculate_max }
+          else
+            options[:max] = max_value
+            self
+          end
+        end
+
+        private
+
+        def calculate_max
+          if (numericality_validator = find_numericality_validator)
+            get_max_from_validator(numericality_validator)
+          elsif (max = get_max_from_attribute(key))
+            max
+          end
+        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_max(max)
+          return nil unless max
+
+          value = evaluate_numericality_validator_option(max[:value])
+          max[:exclusive] ? value - 1 : value
+        end
+
+        def get_max_from_attribute(attribute)
+          if object.class.respond_to?(:attribute_types) && (attribute_type = object.class.attribute_types[attribute.to_s])
+            if (range = attribute_type.instance_variable_get(:@range))
+              range.max
+            elsif attribute_type.respond_to?(:precision) && (precision = attribute_type.precision)
+              (precision**8) - ((step && step != "any") ? step : 0.000001)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/options/min.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Options
+      module Min
+        def min(min_value = nil)
+          if min_value.nil?
+            options.fetch(:min) { options[:min] = calculate_min }
+          else
+            options[:min] = min_value
+            self
+          end
+        end
+
+        private
+
+        def calculate_min
+          if (numericality_validator = find_numericality_validator)
+            get_min_from_validator(numericality_validator)
+          elsif (min = get_min_from_attribute(key))
+            min
+          end
+        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 evaluate_and_adjust_min(min)
+          return nil unless min
+
+          value = evaluate_numericality_validator_option(min[:value])
+          min[:exclusive] ? value + 1 : value
+        end
+
+        def get_min_from_attribute(attribute)
+          if object.class.respond_to?(:attribute_types) && (attribute_type = object.class.attribute_types[attribute.to_s])
+            if (range = attribute_type.instance_variable_get(:@range))
+              range.min
+            elsif attribute_type.respond_to?(:precision) && (precision = attribute_type.precision)
+              -((precision**8) - ((step && step != "any") ? step : 0.000001))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/{field_options → options}/pattern.rb

@@ -2,11 +2,11 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Pattern
         def pattern(pattern = nil)
           if pattern.nil?
-            options[:pattern] = options.fetch(:pattern) { calculate_pattern }
+            options.fetch(:pattern) { options[:pattern] = calculate_pattern }
           else
             options[:pattern] = pattern
             self

data/lib/phlexi/form/{field_options → options}/readonly.rb

@@ -2,7 +2,7 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Readonly
         def readonly?
           options[:readonly] == true

data/lib/phlexi/form/{field_options → options}/required.rb

@@ -2,10 +2,10 @@
 
 module Phlexi
   module Form
-    module FieldOptions
+    module Options
       module Required
         def required?
-          options[:required] = options.fetch(:required) { calculate_required }
+          options.fetch(:required) { options[:required] = calculate_required }
         end
 
         def required!(required = true)

data/lib/phlexi/form/options/step.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Options
+      module Step
+        def step(value = nil)
+          if value.nil?
+            options.fetch(:step) { options[:step] = calculate_step }
+          else
+            options[:step] = value
+            self
+          end
+        end
+
+        private
+
+        def calculate_step
+          if (scale = get_scale_from_attribute(key))
+            return 1.fdiv(10**scale)
+          end
+
+          case inferred_field_type
+          when :integer
+            1
+          when :decimal, :float
+            "any"
+          end
+        end
+
+        def get_scale_from_attribute(attribute)
+          if object.class.respond_to?(:attribute_types) && (attribute_type = object.class.attribute_types[attribute.to_s])
+            attribute_type.scale if attribute_type.respond_to?(:scale)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/phlexi/form/options/validators.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Phlexi
+  module Form
+    module Options
+      module Validators
+        private
+
+        def find_numericality_validator
+          find_validator(:numericality)
+        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/structure/field_collection.rb

@@ -1,24 +1,10 @@
 # frozen_string_literal: true
 
-require "phlex"
-
 module Phlexi
   module Form
     module Structure
-      class FieldCollection
-        include Enumerable
-
-        class Builder
-          include Phlex::Helpers
-
-          attr_reader :key, :index
-
-          def initialize(key, field, index)
-            @key = key.to_s
-            @field = field
-            @index = index
-          end
-
+      class FieldCollection < Phlexi::Field::Structure::FieldCollection
+        class Builder < Builder
           def field(**options)
             options = mix({input_attributes: @field.input_attributes}, options)
             @field.class.new(key, **options, parent: @field).tap do |field|
@@ -35,22 +21,16 @@ module Phlexi
           end
         end
 
-        def initialize(field:, range:, &)
-          @field = field
-          @range = case range
+        private
+
+        def build_collection(collection)
+          case collection
           when Range, Array
-            range
+            collection
           when Integer
-            1..range
+            1..collection
           else
-            range.to_a
-          end
-          each(&) if block_given?
-        end
-
-        def each(&)
-          @range.each.with_index do |key, index|
-            yield Builder.new(key, @field, index)
+            collection.to_a
           end
         end
       end

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

@@ -3,81 +3,13 @@
 module Phlexi
   module Form
     module Structure
-      # A Namespace maps an object to values, but doesn't actually have a value itself. For
-      # example, a `User` object or ActiveRecord model could be passed into the `:user` namespace.
-      #
-      # To access single values on a Namespace, #field can be used.
-      #
-      # To access nested objects within a namespace, two methods are available:
-      #
-      # 1. #nest_one: Used for single nested objects, such as if a `User belongs_to :profile` in
-      #    ActiveRecord. This method returns another Namespace object.
-      #
-      # 2. #nest_many: Used for collections of nested objects, such as if a `User has_many :addresses` in
-      #    ActiveRecord. This method returns a NamespaceCollection object.
-      class Namespace < Structure::Node
-        include Enumerable
-
-        attr_reader :builder_klass, :object
-
-        def initialize(key, parent:, builder_klass:, object: nil)
-          super(key, parent: parent)
-          @builder_klass = builder_klass
-          @object = object
-          @children = {}
-          yield self if block_given?
-        end
-
-        def field(key, **attributes)
-          create_child(key, attributes.delete(:builder_klass) || builder_klass, object: object, **attributes).tap do |field|
-            yield field if block_given?
-          end
-        end
+      class Namespace < Phlexi::Field::Structure::Namespace
+        class NamespaceCollection < Phlexi::Form::Structure::NamespaceCollection; end
 
         def submit_button(key = :submit_button, **, &)
           field(key).submit_button_tag(**, &)
         end
 
-        # Creates a `Namespace` child instance with the parent set to the current instance, adds to
-        # the `@children` Hash to ensure duplicate child namespaces aren't created, then calls the
-        # method on the `@object` to get the child object to pass into that namespace.
-        #
-        # For example, if a `User#permission` returns a `Permission` object, we could map that to a
-        # form like this:
-        #
-        # ```ruby
-        # Phlexi::Form(User.new, as: :user) do
-        #   nest_one :profile do |profile|
-        #     render profile.field(:gender).input_tag
-        #   end
-        # end
-        # ```
-        def nest_one(key, object: nil, &)
-          object ||= object_value_for(key: key)
-          create_child(key, self.class, object:, builder_klass:, &)
-        end
-
-        # Wraps an array of objects in Namespace classes. For example, if `User#addresses` returns
-        # an enumerable or array of `Address` classes:
-        #
-        # ```ruby
-        # Phlexi::Form(User.new) do
-        #   render field(:email).input_tag
-        #   render field(:name).input_tag
-        #   nest_many :addresses do |address|
-        #     render address.field(:street).input_tag
-        #     render address.field(:state).input_tag
-        #     render address.field(:zip).input_tag
-        #   end
-        # end
-        # ```
-        # The object within the block is a `Namespace` object that maps each object within the enumerable
-        # to another `Namespace` or `Field`.
-        def nest_many(key, collection: nil, &)
-          collection ||= Array(object_value_for(key: key))
-          create_child(key, NamespaceCollection, collection:, &)
-        end
-
         def extract_input(params)
           if params.is_a?(Array)
             each_with_object({}) do |child, hash|
@@ -90,50 +22,6 @@ module Phlexi
             {key => input}
           end
         end
-
-        # Iterates through the children of the current namespace, which could be `Namespace` or `Field`
-        # objects.
-        def each(&)
-          @children.values.each(&)
-        end
-
-        def dom_id
-          @dom_id ||= begin
-            id = if object.nil?
-              nil
-            elsif object.class.respond_to?(:primary_key)
-              object.public_send(object.class.primary_key) || :new
-            elsif object.respond_to?(:id)
-              object.id || :new
-            end
-            [key, id].compact.join("_").underscore
-          end
-        end
-
-        # Creates a root Namespace, which is essentially a form.
-        def self.root(*, builder_klass:, **, &)
-          new(*, parent: nil, builder_klass:, **, &)
-        end
-
-        protected
-
-        # Calls the corresponding method on the object for the `key` name, if it exists. For example
-        # if the `key` is `email` on `User`, this method would call `User#email` if the method is
-        # present.
-        #
-        # This method could be overwritten if the mapping between the `@object` and `key` name is not
-        # a method call. For example, a `Hash` would be accessed via `user[:email]` instead of `user.send(:email)`
-        def object_value_for(key:)
-          @object.send(key) if @object.respond_to? key
-        end
-
-        private
-
-        # Checks if the child exists. If it does then it returns that. If it doesn't, it will
-        # build the child.
-        def create_child(key, child_class, **kwargs, &block)
-          @children.fetch(key) { @children[key] = child_class.new(key, parent: self, **kwargs, &block) }
-        end
       end
     end
   end