phlexi-form 0.3.0.rc1 → 0.4.0

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
@@ -21,14 +21,28 @@ module Phlexi
           object_with_errors? || !object && has_custom_error?
         end
 
-        def show_errors?
+        def can_show_errors?
           options[:error] != false
         end
 
+        def show_errors?
+          can_show_errors? && has_errors?
+        end
+
         def valid?
           !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
@@ -66,26 +80,16 @@ module Phlexi
         end
 
         def errors_on_association
-          reflection ? object.errors[reflection.name] : []
+          association_reflection ? object.errors[association_reflection.name] : []
         end
 
         def full_errors_on_association
-          reflection ? object.errors.full_messages_for(reflection.name) : []
+          association_reflection ? object.errors.full_messages_for(association_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

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)
@@ -24,7 +24,7 @@ module Phlexi
         end
 
         def required_by_validators?
-          (attribute_validators + reflection_validators).any? { |v| v.kind == :presence && valid_validator?(v) }
+          (attribute_validators + association_reflection_validators).any? { |v| v.kind == :presence && valid_validator?(v) }
         end
 
         def required_by_default?

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

@@ -3,20 +3,11 @@
 module Phlexi
   module Form
     module Structure
-      class FieldCollection
-        include Enumerable
-
-        class Builder
-          attr_reader :key, :index
-
-          def initialize(key, field, index)
-            @key = key.to_s
-            @field = field
-            @index = index
-          end
-
-          def field(**)
-            @field.class.new(key, input_attributes: @field.input_attributes, **, parent: @field).tap do |field|
+      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|
               yield field if block_given?
             end
           end
@@ -30,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,74 +3,11 @@
 module Phlexi
   module Form
     module Structure
-      # A Namespace maps and 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 the values on a Namespace, the `field` can be called for single values.
-      #
-      # Additionally, to access namespaces within a namespace, such as if a `User has_many :addresses` in
-      # ActiveRecord, the `namespace` method can be called which will return another Namespace object and
-      # set the current Namespace as the parent.
-      class Namespace < Structure::Node
-        include Enumerable
+      class Namespace < Phlexi::Field::Structure::Namespace
+        class NamespaceCollection < Phlexi::Form::Structure::NamespaceCollection; end
 
-        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
-
-        def submit_button(key = nil, **attributes, &)
-          field(key || SecureRandom.hex).submit_button_tag(**attributes, &)
-        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
-        # Superform :user, object: User.new do |form|
-        #   form.nest_one :permission do |permission|
-        #     form.field :role
-        #   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.new User.new do |form|
-        #   render form.field(:email).input_tag
-        #   render form.field(:name).input_tag
-        #   form.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:, &)
+        def submit_button(key = :submit_button, **, &)
+          field(key).submit_button_tag(**, &)
         end
 
         def extract_input(params)
@@ -85,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

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

@@ -3,19 +3,7 @@
 module Phlexi
   module Form
     module Structure
-      class NamespaceCollection < Node
-        include Enumerable
-
-        def initialize(key, parent:, collection: nil, &block)
-          raise ArgumentError, "block is required" unless block.present?
-
-          super(key, parent: parent)
-
-          @collection = collection
-          @block = block
-          each(&block)
-        end
-
+      class NamespaceCollection < Phlexi::Field::Structure::NamespaceCollection
         def extract_input(params)
           namespace = build_namespace(0)
           @block.call(namespace)
@@ -23,25 +11,6 @@ module Phlexi
           inputs = params[key].map { |param| namespace.extract_input([param]) }
           {key => inputs}
         end
-
-        private
-
-        def each(&)
-          namespaces.each(&)
-        end
-
-        # Builds and memoizes namespaces for the collection.
-        #
-        # @return [Array<Hash>] An array of namespace hashes.
-        def namespaces
-          @namespaces ||= @collection.map.with_index do |object, key|
-            build_namespace(key, object: object)
-          end
-        end
-
-        def build_namespace(index, **)
-          parent.class.new(index, parent: self, builder_klass: parent.builder_klass, **)
-        end
       end
     end
   end