hakumi_components 0.1.18.pre → 0.1.19.pre

data/lib/hakumi_components/engine.rb

@@ -1,22 +1,25 @@
+# typed: strict
 # frozen_string_literal: true
 
 require "pathname"
 
 module HakumiComponents
   class Engine < ::Rails::Engine
+    extend T::Sig
+
     isolate_namespace HakumiComponents
 
-    root = Pathname.new(File.expand_path("../..", __dir__ || "."))
-    config.root = root
+    ROOT = T.let(Pathname.new(File.expand_path("../..", __dir__ || ".")), Pathname)
+    config.root = ROOT
 
-    config.autoload_paths << root.join("app/components")
-    config.eager_load_paths << root.join("app/components")
+    config.autoload_paths << ROOT.join("app/components")
+    config.eager_load_paths << ROOT.join("app/components")
 
-    config.autoload_paths << root.join("app/form_builders")
-    config.eager_load_paths << root.join("app/form_builders")
+    config.autoload_paths << ROOT.join("app/form_builders")
+    config.eager_load_paths << ROOT.join("app/form_builders")
 
-    config.autoload_paths << root.join("app/helpers")
-    config.eager_load_paths << root.join("app/helpers")
+    config.autoload_paths << ROOT.join("app/helpers")
+    config.eager_load_paths << ROOT.join("app/helpers")
 
     initializer "hakumi.helpers" do
       ActiveSupport.on_load(:action_view) do
@@ -25,14 +28,17 @@ module HakumiComponents
     end
 
     initializer "hakumi.assets" do |app|
-      # Only add assets path if Sprockets is available (Rails < 8 or when explicitly added)
       if app.config.respond_to?(:assets)
-        app.config.assets.paths << root.join("app/assets")
+        app.config.assets.paths << ROOT.join("app/assets")
       end
     end
 
     initializer "hakumi.views" do |app|
-      app.config.paths["app/views"] << root.join("app/views")
+      app.config.paths["app/views"] << ROOT.join("app/views")
+    end
+
+    initializer "hakumi.i18n" do
+      config.i18n.load_path += Dir[ROOT.join("lib/hakumi_components/locales/**/*.yml")]
     end
 
     initializer "hakumi.form_builder", after: :load_config_initializers do |app|

data/lib/hakumi_components/file_size_checker.rb

@@ -0,0 +1,215 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "pathname"
+require "sorbet-runtime"
+require "yaml"
+
+module HakumiComponents
+  class FileSizeChecker
+    extend T::Sig
+
+    class Rule < T::Struct
+      const :name, String
+      const :pattern, String
+      const :threshold, Integer
+    end
+
+    class Finding < T::Struct
+      extend T::Sig
+
+      const :rule_name, String
+      const :path, String
+      const :lines, Integer
+      const :threshold, Integer
+      const :approved_limit, T.nilable(Integer)
+
+      sig { returns(T::Boolean) }
+      def approved?
+        limit = approved_limit
+        !limit.nil? && lines <= limit
+      end
+
+      sig { returns(T::Boolean) }
+      def violation?
+        !approved?
+      end
+
+      sig { returns(Integer) }
+      def over_threshold_by
+        lines - threshold
+      end
+
+      sig { returns(T.nilable(Integer)) }
+      def over_approved_by
+        limit = approved_limit
+        return nil if limit.nil?
+
+        lines - limit
+      end
+
+      sig { returns(String) }
+      def status
+        return "approved" if approved?
+        return "regressed" unless approved_limit.nil?
+
+        "unapproved"
+      end
+    end
+
+    REPO_ROOT = T.let(Pathname.new(__dir__).join("../..").expand_path, Pathname)
+
+    DEFAULT_RULES = T.let([
+      Rule.new(
+        name: "Ruby component",
+        pattern: "app/components/hakumi_components/**/component.rb",
+        threshold: 500
+      ),
+      Rule.new(
+        name: "Hakumi Stimulus controller",
+        pattern: "app/javascript/hakumi_components/controllers/hakumi/*_controller.js",
+        threshold: 700
+      )
+    ].freeze, T::Array[Rule])
+
+    EXCEPTIONS_PATH = T.let(Pathname.new("docs/file_size_exceptions.yml"), Pathname)
+
+    sig { params(root: Pathname).returns(T::Hash[String, Integer]) }
+    def self.load_approved_exceptions(root: REPO_ROOT)
+      path = root.join(EXCEPTIONS_PATH)
+      return {} unless path.exist?
+
+      data = YAML.safe_load(path.read, aliases: false) || {}
+      exceptions = T.let({}, T::Hash[String, Integer])
+
+      T.cast(data, T::Hash[String, T.untyped]).each_value do |entries|
+        next unless entries.is_a?(Hash)
+
+        entries.each do |relative_path, config|
+          next unless config.is_a?(Hash)
+
+          baseline = config["baseline_lines"]
+          next if baseline.nil?
+
+          exceptions[relative_path.to_s] = Integer(baseline)
+        end
+      end
+
+      exceptions
+    end
+
+    sig do
+      params(
+        root: Pathname,
+        rules: T::Array[Rule],
+        approved_exceptions: T.nilable(T::Hash[String, Integer])
+      ).void
+    end
+    def initialize(root: REPO_ROOT, rules: DEFAULT_RULES, approved_exceptions: nil)
+      @root = T.let(root, Pathname)
+      @rules = T.let(rules, T::Array[Rule])
+      @approved_exceptions = T.let(approved_exceptions || self.class.load_approved_exceptions(root: root),
+        T::Hash[String, Integer])
+    end
+
+    sig { returns(T::Array[Finding]) }
+    def findings
+      @rules.flat_map do |rule|
+        matching_paths(rule).filter_map do |path|
+          lines = line_count(path)
+          next if lines <= rule.threshold
+
+          relative_path = relative_path_for(path)
+          Finding.new(
+            rule_name: rule.name,
+            path: relative_path,
+            lines: lines,
+            threshold: rule.threshold,
+            approved_limit: @approved_exceptions[relative_path]
+          )
+        end
+      end.sort_by { |finding| [ finding.rule_name, finding.path ] }
+    end
+
+    sig { returns(T::Array[Finding]) }
+    def violations
+      findings.select(&:violation?)
+    end
+
+    sig { params(strict: T::Boolean).returns(T::Boolean) }
+    def success?(strict: false)
+      !strict || violations.empty?
+    end
+
+    sig { params(strict: T::Boolean).returns(String) }
+    def report(strict: false)
+      current_findings = findings
+
+      lines = []
+      lines << "File size guardrail#{strict ? ' (strict)' : ' (warning-only)'}"
+      lines << ""
+      lines << "Thresholds:"
+      @rules.each do |rule|
+        lines << "- #{rule.name}: #{rule.threshold} lines (#{rule.pattern})"
+      end
+      lines << ""
+
+      if current_findings.empty?
+        lines << "All tracked files are within their thresholds."
+        return lines.join("\n")
+      end
+
+      approved, actionable = current_findings.partition(&:approved?)
+
+      unless approved.empty?
+        lines << "Approved exceptions:"
+        approved.each do |finding|
+          lines << format_finding(finding)
+        end
+        lines << ""
+      end
+
+      unless actionable.empty?
+        lines << "Actionable overages:"
+        actionable.each do |finding|
+          lines << format_finding(finding)
+        end
+        lines << ""
+      end
+
+      unless strict
+        lines << "This check is currently non-blocking. Run `bin/check-file-sizes --strict` to fail on actionable overages."
+      end
+
+      lines.join("\n").strip
+    end
+
+    private
+
+    sig { params(rule: Rule).returns(T::Array[Pathname]) }
+    def matching_paths(rule)
+      Dir.glob(@root.join(rule.pattern).to_s).map { |path| Pathname.new(path) }.sort
+    end
+
+    sig { params(path: Pathname).returns(Integer) }
+    def line_count(path)
+      count = T.let(0, Integer)
+      path.each_line { count += 1 }
+      count
+    end
+
+    sig { params(path: Pathname).returns(String) }
+    def relative_path_for(path)
+      path.relative_path_from(@root).to_s
+    end
+
+    sig { params(finding: Finding).returns(String) }
+    def format_finding(finding)
+      base = "- #{finding.path}: #{finding.lines} lines (limit #{finding.threshold}, +#{finding.over_threshold_by})"
+      approved_limit = finding.approved_limit
+      return "#{base}; approved exception up to #{approved_limit}" unless approved_limit.nil?
+
+      "#{base}; no approved exception"
+    end
+  end
+end

data/lib/hakumi_components/locales/en.yml

@@ -0,0 +1,115 @@
+en:
+  hakumi_components:
+    # Modal variants
+    modal:
+      info:
+        title: "Info"
+        ok: "OK"
+      confirm:
+        title: "Confirm"
+        ok: "OK"
+        cancel: "Cancel"
+      error:
+        title: "Error"
+        ok: "OK"
+      warning:
+        title: "Warning"
+        ok: "Proceed"
+        cancel: "Cancel"
+      success:
+        title: "Success"
+        ok: "OK"
+
+    # Image component
+    image:
+      preview: "Preview"
+      flip_vertical: "Flip Vertical"
+      flip_horizontal: "Flip Horizontal"
+      rotate_left: "Rotate Left"
+      rotate_right: "Rotate Right"
+      zoom_out: "Zoom Out"
+      zoom_in: "Zoom In"
+
+    # QR Code component
+    qr_code:
+      aria_label: "QR Code"
+      status:
+        expired: "Expired"
+        loading: "Loading"
+        scanned: "Scanned"
+        active: "Active"
+      description:
+        expired: "Please refresh to continue"
+        scanned: "You can now continue"
+
+    # Typography component
+    typography:
+      copied: "Copied!"
+      copy_failed: "Copy failed"
+      copy_aria_label: "Copy"
+
+    # Transfer component
+    transfer:
+      source_title: "Source"
+      target_title: "Target"
+      search_placeholder: "Search"
+
+    # Autocomplete component
+    autocomplete:
+      not_found: "No options"
+
+    # Color Picker component
+    color_picker:
+      default_preset_label: "Recommended"
+      presets_label: "Presets"
+
+    # Date Picker component
+    date_picker:
+      placeholder: "Select date"
+      start_placeholder: "Start date"
+      end_placeholder: "End date"
+
+    # Pagination component
+    pagination:
+      total: "Total %{count} items"
+
+    # Table component
+    table:
+      select_all: "Select all"
+      invert: "Invert"
+      clear: "Clear"
+      search_placeholder: "Search"
+      reset: "Reset"
+
+    # Tabs component
+    tabs:
+      remove_tab_aria_label: "Remove tab"
+
+    # Empty component
+    empty:
+      description: "No data"
+
+    # Cascader component
+    cascader:
+      placeholder: "Select"
+
+    # Tree Select component
+    tree_select:
+      placeholder: "Select"
+
+    # Tree component
+    tree:
+      search_placeholder: "Search"
+
+    # Message component
+    message:
+      default_content: "Generated message content."
+      close: "Close"
+
+    # Upload component
+    upload:
+      preview: "Preview"
+      remove: "Remove"
+      close: "Close"
+      previous: "Previous"
+      next: "Next"

data/lib/hakumi_components/rails/attribute_introspection.rb

@@ -1,154 +1,86 @@
+# typed: strict
 # frozen_string_literal: true
 
 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