hakumi_components 0.1.17.pre → 0.1.19.pre

data/lib/hakumi_components/rails/attribute_introspection.rb

@@ -1,154 +1,86 @@
+# typed: strict
 # frozen_string_literal: true
 
-module Hakumi
+module HakumiComponents
   module Rails
-    # Introspects ActiveRecord schema and I18n translations to automatically
-    # configure form field labels, placeholders, and hints
     class AttributeIntrospection
       class << self
-        # Get human-readable attribute name from I18n
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [String, nil]
-        def human_attribute_name(object, attribute)
-          return nil unless object
-          return nil unless object.class.respond_to?(:human_attribute_name)
+        extend T::Sig
 
-          # Use ActiveModel's human_attribute_name which looks up I18n translations
-          # Falls back to humanized attribute name
-          object.class.public_send(:human_attribute_name, attribute)
+        sig { params(object: T.untyped, attribute: Symbol).returns(T.nilable(String)) }
+        def human_attribute_name(object, attribute)
+          ModelReflection.for(object).human_attribute_name(attribute)
         end
 
-        # Get placeholder text from I18n
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [String, nil]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T.nilable(String)) }
         def placeholder(object, attribute)
-          return nil unless object
           return nil unless defined?(I18n)
+          model_name = ModelReflection.for(object).model_i18n_key
+          return nil unless model_name
 
-          model_name = object.class.respond_to?(:model_name) ? object.class.public_send(:model_name) : nil
-          return nil unless model_name && model_name.respond_to?(:i18n_key)
-          model_name = model_name.public_send(:i18n_key)
           key = "helpers.placeholder.#{model_name}.#{attribute}"
 
           I18n.t(key, default: "").presence
         end
 
-        # Get hint/help text from I18n
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [String, nil]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T.nilable(String)) }
         def hint(object, attribute)
-          return nil unless object
           return nil unless defined?(I18n)
+          model_name = ModelReflection.for(object).model_i18n_key
+          return nil unless model_name
 
-          model_name = object.class.respond_to?(:model_name) ? object.class.public_send(:model_name) : nil
-          return nil unless model_name && model_name.respond_to?(:i18n_key)
-          model_name = model_name.public_send(:i18n_key)
           key = "helpers.hint.#{model_name}.#{attribute}"
 
           I18n.t(key, default: "").presence
         end
 
-        # Detect HTML input type from database column type
-        #
-        # @param object [ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Symbol] :text, :number, :email, :url, :date, :datetime, :time, etc.
+        sig { params(object: T.untyped, attribute: Symbol).returns(Symbol) }
         def input_type_from_column(object, attribute)
-          return :text unless object
-          return :text unless defined?(ActiveRecord::Base)
-          return :text unless object.is_a?(ActiveRecord::Base) || object.class < ActiveRecord::Base
-
-          column = column_for(object, attribute)
-          return :text unless column
-
-          column_type = column.respond_to?(:type) ? column.public_send(:type) : nil
-          case column_type
-          when :integer, :decimal, :float
-            :number
-          when :date
-            :date
-          when :datetime, :timestamp
-            :datetime_local
-          when :time
-            :time
-          when :boolean
-            :checkbox
-          when :text
-            :textarea
-          else
-            :text
+          column = ModelReflection.for(object).column_for(attribute)
+          return :text unless column&.type
+
+          case column.type
+          when :integer, :decimal, :float then :number
+          when :date then :date
+          when :datetime, :timestamp then :datetime_local
+          when :time then :time
+          when :boolean then :checkbox
+          when :text then :textarea
+          else :text
           end
         end
 
-        # Get database column for attribute
-        #
-        # @param object [ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [ActiveRecord::ConnectionAdapters::Column, nil]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T.nilable(HakumiComponents::Rails::ModelReflection::ColumnInfo)) }
         def column_for(object, attribute)
-          return nil unless object
-          return nil unless defined?(ActiveRecord::Base)
-          return nil unless object.class < ActiveRecord::Base
-          return nil unless object.class.respond_to?(:columns_hash)
-
-          columns_hash = object.class.respond_to?(:columns_hash) ? object.class.public_send(:columns_hash) : nil
-          return columns_hash[attribute.to_s] if columns_hash.is_a?(Hash)
-          nil
+          ModelReflection.for(object).column_for(attribute)
         end
 
-        # Check if column is numeric
-        #
-        # @param object [ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Boolean]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T::Boolean) }
         def numeric_column?(object, attribute)
           column = column_for(object, attribute)
-          return false unless column
-
-          column_type = column.respond_to?(:type) ? column.public_send(:type) : nil
-          case column_type
-          when :integer, :decimal, :float
-            true
-          else
-            false
+          return false unless column&.type
+
+          case column.type
+          when :integer, :decimal, :float then true
+          else false
           end
         end
 
-        # Check if column is text/string
-        #
-        # @param object [ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Boolean]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T::Boolean) }
         def text_column?(object, attribute)
           column = column_for(object, attribute)
-          return true unless column # Default to text if no column
-
-          column_type = column.respond_to?(:type) ? column.public_send(:type) : nil
-          case column_type
-          when :string, :text
-            true
-          else
-            false
+          return true unless column&.type
+
+          case column.type
+          when :string, :text then true
+          else false
           end
         end
 
-        # Get SQL column limit (for string columns)
-        #
-        # @param object [ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Integer, nil]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T.nilable(Integer)) }
         def column_limit(object, attribute)
           column = column_for(object, attribute)
-          return nil unless column
-
-          return nil unless column.respond_to?(:limit)
-          column.public_send(:limit)
+          column&.limit
         end
       end
     end

data/lib/hakumi_components/rails/model_reflection.rb

@@ -0,0 +1,154 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Rails
+    class ModelReflection
+      extend T::Sig
+
+      class ColumnInfo
+        extend T::Sig
+
+        sig { params(type: T.nilable(Symbol), limit: T.nilable(Integer)).void }
+        def initialize(type:, limit:)
+          @type = T.let(type, T.nilable(Symbol))
+          @limit = T.let(limit, T.nilable(Integer))
+        end
+
+        sig { returns(T.nilable(Symbol)) }
+        attr_reader :type
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :limit
+      end
+
+      # T.untyped is intentional: object can be an ActiveRecord model, any PORO
+      # with ActiveModel validations, or nil. No meaningful union type captures this.
+      sig { params(object: T.untyped).returns(ModelReflection) }
+      def self.for(object)
+        new(object)
+      end
+
+      sig { params(object: T.untyped).void }
+      def initialize(object)
+        @object = T.let(object, T.untyped)
+      end
+
+      sig { params(attribute: Symbol).returns(T::Array[ActiveModel::Validator]) }
+      def validators_for(attribute)
+        owner = validator_owner
+        return [] unless owner
+
+        raw_validators = owner.public_send(:validators_on, attribute)
+        return [] unless raw_validators.is_a?(Array)
+
+        raw_validators.filter_map do |validator|
+          validator if validator.is_a?(ActiveModel::Validator)
+        end
+      end
+
+      sig { params(attribute: Symbol).returns(T.nilable(String)) }
+      def human_attribute_name(attribute)
+        owner = @object&.class
+        return nil unless owner&.respond_to?(:human_attribute_name)
+
+        value = owner.public_send(:human_attribute_name, attribute)
+        value.is_a?(String) ? value : nil
+      end
+
+      sig { returns(T.nilable(Symbol)) }
+      def model_i18n_key
+        owner = @object&.class
+        return nil unless owner&.respond_to?(:model_name)
+
+        model_name = owner.public_send(:model_name)
+        return nil unless model_name.respond_to?(:i18n_key)
+
+        key = model_name.public_send(:i18n_key)
+        return key.to_sym if key.is_a?(String) || key.is_a?(Symbol)
+
+        nil
+      end
+
+      sig { returns(T.nilable(ActiveModel::Errors)) }
+      def errors
+        return nil unless @object&.respond_to?(:errors)
+
+        value = @object.public_send(:errors)
+        value.is_a?(ActiveModel::Errors) ? value : nil
+      end
+
+      sig { returns(T::Boolean) }
+      def anonymous_class?
+        return true unless @object
+
+        class_name = @object.class.name
+        class_name.nil? || class_name.empty?
+      end
+
+      sig { returns(T::Boolean) }
+      def active_record_object?
+        return false unless defined?(ActiveRecord::Base)
+        return false unless @object
+
+        @object.is_a?(ActiveRecord::Base)
+      end
+
+      sig { returns(T::Boolean) }
+      def validations_available?
+        !validator_owner.nil?
+      end
+
+      sig { params(attribute: Symbol).returns(T.nilable(ColumnInfo)) }
+      def column_for(attribute)
+        return nil unless active_record_object?
+
+        owner = @object&.class
+        return nil unless owner&.respond_to?(:columns_hash)
+
+        columns_hash = owner.public_send(:columns_hash)
+        return nil unless columns_hash.is_a?(Hash)
+
+        build_column_info(columns_hash[attribute.to_s])
+      end
+
+      sig { params(attribute: Symbol).returns(T.untyped) }
+      def attribute_value(attribute)
+        return nil unless @object&.respond_to?(attribute)
+
+        @object.public_send(attribute)
+      rescue StandardError
+        nil
+      end
+
+      private
+
+      sig { returns(T.nilable(T.class_of(BasicObject))) }
+      def validator_owner
+        owner = @object&.class
+        return nil unless owner&.respond_to?(:validators_on)
+
+        owner
+      end
+
+      sig { params(column: T.untyped).returns(T.nilable(ColumnInfo)) }
+      def build_column_info(column)
+        return nil unless column
+
+        type = nil
+        if column.respond_to?(:type)
+          raw_type = column.public_send(:type)
+          type = raw_type if raw_type.is_a?(Symbol)
+        end
+
+        limit = nil
+        if column.respond_to?(:limit)
+          raw_limit = column.public_send(:limit)
+          limit = raw_limit if raw_limit.is_a?(Integer)
+        end
+
+        ColumnInfo.new(type: type, limit: limit)
+      end
+    end
+  end
+end

data/lib/hakumi_components/rails/validation_introspection.rb

@@ -1,16 +1,13 @@
+# typed: strict
 # frozen_string_literal: true
 
-module Hakumi
+module HakumiComponents
   module Rails
-    # Introspects ActiveModel/ActiveRecord validations to automatically
-    # configure form field HTML attributes and client-side validation
     class ValidationIntrospection
       class << self
-        # Check if attribute has presence validation
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Boolean]
+        extend T::Sig
+
+        sig { params(object: T.untyped, attribute: Symbol).returns(T::Boolean) }
         def required?(object, attribute)
           return false unless has_validators?(object)
 
@@ -20,11 +17,7 @@ module Hakumi
           end
         end
 
-        # Get maximum length from length validation
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Integer, nil]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T.nilable(Integer)) }
         def maxlength(object, attribute)
           return nil unless has_validators?(object)
 
@@ -34,16 +27,12 @@ module Hakumi
 
           return nil unless length_validator
 
-          opts = validator_options(length_validator)
+          opts = length_validator.options
           value = opts[:maximum] || opts[:is]
           value.is_a?(Integer) ? value : nil
         end
 
-        # Get minimum length from length validation
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Integer, nil]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T.nilable(Integer)) }
         def minlength(object, attribute)
           return nil unless has_validators?(object)
 
@@ -53,16 +42,12 @@ module Hakumi
 
           return nil unless length_validator
 
-          opts = validator_options(length_validator)
+          opts = length_validator.options
           value = opts[:minimum]
           value.is_a?(Integer) ? value : nil
         end
 
-        # Get pattern (regex) from format validation
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [String, nil]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T.nilable(String)) }
         def pattern(object, attribute)
           return nil unless has_validators?(object)
 
@@ -72,20 +57,14 @@ module Hakumi
 
           return nil unless format_validator
 
-          opts = validator_options(format_validator)
+          opts = format_validator.options
           regex = opts[:with]
           return nil unless regex.is_a?(Regexp)
 
-          # Convert Ruby regex to JavaScript-compatible pattern
-          # Remove anchors (both Ruby \A\z and PCRE ^$) as HTML pattern adds them implicitly
           regex.source.gsub(/\A(\\A|\^)|(\$|\\z)\z/, "")
         end
 
-        # Get min/max values from numericality validation
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Hash] { min: Integer, max: Integer, step: Integer }
+        sig { params(object: T.untyped, attribute: Symbol).returns(T::Hash[Symbol, T.any(Integer, String)]) }
         def numericality_constraints(object, attribute)
           return {} unless has_validators?(object)
 
@@ -95,96 +74,69 @@ module Hakumi
 
           return {} unless numericality_validator
 
-          # @type var constraints: Hash[Symbol, Object]
-          constraints = Hash.new
-          opts = validator_options(numericality_validator)
+          constraints = T.let({}, T::Hash[Symbol, T.any(Integer, String)])
+          opts = numericality_validator.options
 
           min_inclusive = opts[:greater_than_or_equal_to]
           min_exclusive = opts[:greater_than]
           max_inclusive = opts[:less_than_or_equal_to]
           max_exclusive = opts[:less_than]
 
-          constraints[:min] = min_inclusive if min_inclusive.is_a?(Numeric)
-          constraints[:min] = min_exclusive + 1 if min_exclusive.is_a?(Numeric)
-          constraints[:max] = max_inclusive if max_inclusive.is_a?(Numeric)
-          constraints[:max] = max_exclusive - 1 if max_exclusive.is_a?(Numeric)
+          constraints[:min] = min_inclusive.to_i if min_inclusive.is_a?(Numeric)
+          constraints[:min] = min_exclusive.to_i + 1 if min_exclusive.is_a?(Numeric)
+          constraints[:max] = max_inclusive.to_i if max_inclusive.is_a?(Numeric)
+          constraints[:max] = max_exclusive.to_i - 1 if max_exclusive.is_a?(Numeric)
           constraints[:step] = opts[:only_integer] ? 1 : "any"
 
           constraints
         end
 
-        # Detect if field should be email type based on validations
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Boolean]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T::Boolean) }
         def email_field?(object, attribute)
           return false unless has_validators?(object)
-
-          # Check attribute name
           return true if attribute.to_s.match?(/email/i)
 
-          # Check format validation with email-like regex
           format_validator = validators_for(object, attribute).find do |validator|
             validator.is_a?(ActiveModel::Validations::FormatValidator)
           end
 
           return false unless format_validator
 
-          opts = validator_options(format_validator)
+          opts = format_validator.options
           regex = opts[:with]
           return false unless regex.is_a?(Regexp)
 
-          # Common email regex patterns
           regex.source.match?(/email|@.*\./i)
         end
 
-        # Detect if field should be url type based on validations
-        #
-        # @param object [ActiveModel::Model, ActiveRecord::Base]
-        # @param attribute [Symbol]
-        # @return [Boolean]
+        sig { params(object: T.untyped, attribute: Symbol).returns(T::Boolean) }
         def url_field?(object, attribute)
           return false unless has_validators?(object)
-
-          # Check attribute name
           return true if attribute.to_s.match?(/url|website|link/i)
 
-          # Check format validation with url-like regex
           format_validator = validators_for(object, attribute).find do |validator|
             validator.is_a?(ActiveModel::Validations::FormatValidator)
           end
 
           return false unless format_validator
 
-          opts = validator_options(format_validator)
+          opts = format_validator.options
           regex = opts[:with]
           return false unless regex.is_a?(Regexp)
 
-          # Common URL regex patterns
           regex.source.match?(/http|https|:\/\//i)
         end
 
         private
 
+        sig { params(object: T.untyped).returns(T::Boolean) }
         def has_validators?(object)
-          return false unless object
-          return false unless object.class.respond_to?(:validators_on)
-          true
+          ModelReflection.for(object).validations_available?
         end
 
+        sig { params(object: T.untyped, attribute: Symbol).returns(T::Array[ActiveModel::Validator]) }
         def validators_for(object, attribute)
-          return [] unless object
-          return [] unless object.class.respond_to?(:validators_on)
-
-          object.class.public_send(:validators_on, attribute)
-        end
-
-        def validator_options(validator)
-          # @type var opts: Hash[Symbol, Object]
-          opts = validator.respond_to?(:options) ? validator.public_send(:options) : Hash.new
-          opts = opts.to_h if opts.respond_to?(:to_h)
-          opts.is_a?(Hash) ? opts : {}
+          ModelReflection.for(object).validators_for(attribute)
         end
       end
     end