phlexi-display 0.0.1 → 0.0.3

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

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

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

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

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

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

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

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

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

@@ -1,207 +0,0 @@
-# frozen_string_literal: true
-
-module Phlexi
-  module Display
-    module FieldOptions
-      module Themes
-        # Resolves theme classes for components based on their type and the validity state of the field.
-        #
-        # This method is responsible for determining the appropriate CSS classes for a given form component.
-        # It considers both the base theme for the component type and any additional theming based on the
-        # component's validity state (valid, invalid, or neutral). The method supports a hierarchical
-        # theming system, allowing for cascading themes and easy customization.
-        #
-        # @param component [Symbol, String] The type of form component (e.g., :input, :label, :wrapper)
-        #
-        # @return [String, nil] A string of CSS classes for the component, or nil if no theme is applied
-        #
-        # @example Basic usage
-        #   themed(:input)
-        #   # => "w-full p-2 border rounded-md shadow-sm font-medium text-sm dark:bg-gray-700"
-        #
-        # @example Usage with validity state
-        #   # Assuming the field has errors
-        #   themed(:input)
-        #   # => "w-full p-2 border rounded-md shadow-sm font-medium text-sm dark:bg-gray-700 bg-red-50 border-red-500 text-red-900"
-        #
-        # @example Cascading themes
-        #   # Assuming textarea inherits from input in the theme definition
-        #   themed(:textarea)
-        #   # => "w-full p-2 border rounded-md shadow-sm font-medium text-sm dark:bg-gray-700"
-        #
-        # @note The actual CSS classes returned will depend on the theme definitions in the `theme` hash
-        #       and any overrides specified in the `options` hash.
-        #
-        # @see #resolve_theme
-        # @see #resolve_validity_theme
-        # @see #theme
-        def themed(component)
-          return unless component
-
-          tokens(resolve_theme(component), resolve_validity_theme(component)).presence
-        end
-
-        protected
-
-        # Recursively resolves the theme for a given property, handling nested symbol references
-        #
-        # @param property [Symbol, String] The theme property to resolve
-        # @param visited [Set] Set of already visited properties to prevent infinite recursion
-        # @return [String, nil] The resolved theme value or nil if not found
-        #
-        # @example Resolving a nested theme
-        #   # Assuming the theme is: { input: :base_input, base_input: "some-class" }
-        #   resolve_theme(:input)
-        #   # => "some-class"
-        def resolve_theme(property, visited = Set.new)
-          return nil if !property.present? || visited.include?(property)
-          visited.add(property)
-
-          result = theme[property]
-          if result.is_a?(Symbol)
-            resolve_theme(result, visited)
-          else
-            result
-          end
-        end
-
-        # Resolves the theme for a component based on its current validity state
-        #
-        # This method determines the validity state of the field (valid, invalid, or neutral)
-        # and returns the corresponding theme by prepending the state to the component name.
-        #
-        # @param property [Symbol, String] The base theme property to resolve
-        # @return [String, nil] The resolved validity-specific theme or nil if not found
-        #
-        # @example Resolving a validity theme
-        #   # Assuming the field has errors and the theme includes { invalid_input: "error-class" }
-        #   resolve_validity_theme(:input)
-        #   # => "error-class"
-        def resolve_validity_theme(property)
-          validity_property = if has_errors?
-            :"invalid_#{property}"
-          elsif object_valid?
-            :"valid_#{property}"
-          else
-            :"neutral_#{property}"
-          end
-
-          resolve_theme(validity_property)
-        end
-
-        # Retrieves or initializes the theme hash for the form builder.
-        #
-        # This method returns a hash containing theme definitions for various form components.
-        # If a theme has been explicitly set in the options, it returns that. Otherwise, it
-        # initializes and returns a default theme.
-        #
-        # The theme hash defines CSS classes or references to other theme keys for different
-        # components and their states (e.g., valid, invalid, neutral).
-        #
-        # @return [Hash] A hash containing theme definitions for form components
-        #
-        # @example Accessing the theme
-        #   theme[:input]
-        #   # => "w-full p-2 border rounded-md shadow-sm font-medium text-sm dark:bg-gray-700"
-        #
-        # @example Accessing a validity-specific theme
-        #   theme[:invalid_input]
-        #   # => "bg-red-50 border-red-500 text-red-900 placeholder-red-700 focus:ring-red-500 focus:border-red-500"
-        #
-        # @example Theme inheritance
-        #   theme[:textarea] # Returns :input, indicating textarea inherits input's theme
-        #   theme[:valid_textarea] # Returns :valid_input
-        #
-        # @note The actual content of the theme hash depends on the default_theme method
-        #       and any theme overrides specified in the options when initializing the field builder.
-        #
-        # @see #default_theme
-        def theme
-          @theme ||= options[:theme] || default_theme
-        end
-
-        # Defines and returns the default theme hash for the field builder.
-        #
-        # This method returns a hash containing the base theme definitions for various components.
-        # It sets up the default styling and relationships between different components and their states.
-        # The theme uses a combination of explicit CSS classes and symbolic references to other theme keys,
-        # allowing for a flexible and inheritance-based theming system.
-        #
-        # @return [Hash] A frozen hash containing default theme definitions for components
-        #
-        # @example Accessing the default theme
-        #   default_theme[:input]
-        #   # => nil (indicates that :input doesn't have a default and should be defined by the user)
-        #
-        # @example Theme inheritance
-        #   default_theme[:textarea]
-        #   # => :input (indicates that :textarea inherits from :input)
-        #
-        # @example Validity state theming
-        #   default_theme[:valid_textarea]
-        #   # => :valid_input (indicates that :valid_textarea inherits from :valid_input)
-        #
-        # @note This method returns a frozen hash to prevent accidental modifications.
-        #       To customize the theme, users should provide their own theme hash when initializing the field builder.
-        # @note Most theme values are set to nil or commented out in the default theme to encourage users
-        #       to define their own styles while maintaining the relationships between components and states.
-        #
-        # @see #theme
-        def default_theme
-          {
-            # # input
-            # input: nil,
-            # valid_input: nil,
-            # invalid_input: nil,
-            # neutral_input: nil,
-
-            # textarea
-            textarea: :input,
-            valid_textarea: :valid_input,
-            invalid_textarea: :invalid_input,
-            neutral_textarea: :neutral_input,
-
-            # select
-            select: :input,
-            valid_select: :valid_input,
-            invalid_select: :invalid_input,
-            neutral_select: :neutral_input,
-
-            # file
-            file: :input,
-            valid_file: :valid_input,
-            invalid_file: :invalid_input,
-            neutral_file: :neutral_input,
-
-            # misc
-            # label: nil,
-            # hint: nil,
-            # error: nil,
-            full_error: :error,
-            # wrapper: nil,
-            # inner_wrapper: nil,
-            submit_button: :button
-
-            # # label themes
-            # label: "md:w-1/6 mt-2 block mb-2 text-sm font-medium",
-            # invalid_label: "text-red-700 dark:text-red-500",
-            # valid_label: "text-green-700 dark:text-green-500",
-            # neutral_label: "text-gray-700 dark:text-white",
-            # # input themes
-            # input: "w-full p-2 border rounded-md shadow-sm font-medium text-sm dark:bg-gray-700",
-            # invalid_input: "bg-red-50 border-red-500 dark:border-red-500 text-red-900 dark:text-red-500 placeholder-red-700 dark:placeholder-red-500 focus:ring-red-500 focus:border-red-500",
-            # valid_input: "bg-green-50 border-green-500 dark:border-green-500 text-green-900 dark:text-green-400 placeholder-green-700 dark:placeholder-green-500 focus:ring-green-500 focus:border-green-500",
-            # neutral_input: "border-gray-300 dark:border-gray-600 dark:placeholder-gray-400 dark:text-white focus:ring-primary-500 focus:border-primary-500",
-            # # hint themes
-            # hint: "mt-2 text-sm text-gray-500 dark:text-gray-200",
-            # # error themes
-            # error: "mt-2 text-sm text-red-600 dark:text-red-500",
-            # # wrapper themes
-            # wrapper: "flex flex-col md:flex-row items-start space-y-2 md:space-y-0 md:space-x-2 mb-4",
-            # inner_wrapper: "md:w-5/6 w-full",
-          }.freeze
-        end
-      end
-    end
-  end
-end

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

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