hakumi_components 0.1.17.pre → 0.1.19.pre

data/lib/hakumi_components/stylesheet_ownership_checker.rb

@@ -0,0 +1,191 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "pathname"
+require "sorbet-runtime"
+require "yaml"
+
+module HakumiComponents
+  class StylesheetOwnershipChecker
+    extend T::Sig
+
+    class Rule < T::Struct
+      const :name, String
+      const :owner_partial, String
+      const :owned_selectors, T::Array[String]
+      const :forbidden_partials, T::Array[String]
+    end
+
+    class Finding < T::Struct
+      const :rule_name, String
+      const :path, String
+      const :selector, T.nilable(String)
+      const :message, String
+    end
+
+    REPO_ROOT = T.let(Pathname.new(__dir__).join("../..").expand_path, Pathname)
+    CONFIG_PATH = T.let(Pathname.new("docs/stylesheet_ownership.yml"), Pathname)
+
+    sig { params(root: Pathname, config_path: Pathname).returns(T::Array[Rule]) }
+    def self.load_rules(root: REPO_ROOT, config_path: CONFIG_PATH)
+      path = root.join(config_path)
+      return [] unless path.exist?
+
+      data = YAML.safe_load(path.read, aliases: false) || {}
+      rules = T.let([], T::Array[Rule])
+
+      T.cast(data, T::Hash[String, T.untyped]).each do |name, config|
+        next unless config.is_a?(Hash)
+
+        owner_partial = config["owner_partial"]
+        owned_selectors = string_array(config["owned_selectors"])
+        forbidden_partials = string_array(config["forbidden_partials"])
+        next unless owner_partial.is_a?(String) && owned_selectors.any?
+
+        rules << Rule.new(
+          name: name,
+          owner_partial: owner_partial,
+          owned_selectors: owned_selectors,
+          forbidden_partials: forbidden_partials
+        )
+      end
+
+      rules
+    end
+
+    sig { params(root: Pathname, rules: T.nilable(T::Array[Rule])).void }
+    def initialize(root: REPO_ROOT, rules: nil)
+      @root = T.let(root, Pathname)
+      @rules = T.let(rules || self.class.load_rules(root: root), T::Array[Rule])
+    end
+
+    sig { returns(T::Array[Rule]) }
+    attr_reader :rules
+
+    sig { returns(T::Array[Finding]) }
+    def findings
+      current_findings = T.let([], T::Array[Finding])
+
+      @rules.each do |rule|
+        current_findings.concat(owner_findings(rule))
+        current_findings.concat(forbidden_partial_findings(rule))
+      end
+
+      current_findings
+    end
+
+    sig { returns(T::Array[Finding]) }
+    def violations
+      findings
+    end
+
+    sig { returns(T::Boolean) }
+    def success?
+      violations.empty?
+    end
+
+    sig { returns(String) }
+    def report
+      current_findings = findings
+      lines = [ "Stylesheet ownership guardrail", "" ]
+
+      if @rules.empty?
+        lines << "No stylesheet ownership rules are configured."
+        return lines.join("\n")
+      end
+
+      if current_findings.empty?
+        lines << "All configured stylesheet ownership rules pass."
+        return lines.join("\n")
+      end
+
+      lines << "Violations:"
+      current_findings.each do |finding|
+        lines << format_finding(finding)
+      end
+
+      lines.join("\n")
+    end
+
+    private
+
+    sig { params(value: T.untyped).returns(T::Array[String]) }
+    def self.string_array(value)
+      return [] unless value.is_a?(Array)
+
+      value.filter_map { |item| item if item.is_a?(String) }
+    end
+    private_class_method :string_array
+
+    sig { params(rule: Rule).returns(T::Array[Finding]) }
+    def owner_findings(rule)
+      owner_path = path_for(rule.owner_partial)
+      return [ missing_owner_partial(rule) ] unless owner_path.exist?
+
+      content = owner_path.read
+      rule.owned_selectors.filter_map do |selector|
+        next if contains_selector?(content, selector)
+
+        Finding.new(
+          rule_name: rule.name,
+          path: rule.owner_partial,
+          selector: selector,
+          message: "owned selector is missing from owner partial"
+        )
+      end
+    end
+
+    sig { params(rule: Rule).returns(T::Array[Finding]) }
+    def forbidden_partial_findings(rule)
+      findings = T.let([], T::Array[Finding])
+
+      rule.forbidden_partials.each do |relative_path|
+        path = path_for(relative_path)
+        next unless path.exist?
+
+        content = path.read
+        rule.owned_selectors.each do |selector|
+          next unless contains_selector?(content, selector)
+
+          findings << Finding.new(
+            rule_name: rule.name,
+            path: relative_path,
+            selector: selector,
+            message: "owned selector must live in #{rule.owner_partial}"
+          )
+        end
+      end
+
+      findings
+    end
+
+    sig { params(rule: Rule).returns(Finding) }
+    def missing_owner_partial(rule)
+      Finding.new(
+        rule_name: rule.name,
+        path: rule.owner_partial,
+        selector: nil,
+        message: "owner partial is missing"
+      )
+    end
+
+    sig { params(relative_path: String).returns(Pathname) }
+    def path_for(relative_path)
+      @root.join(relative_path)
+    end
+
+    sig { params(content: String, selector: String).returns(T::Boolean) }
+    def contains_selector?(content, selector)
+      pattern = /(?<![-_a-zA-Z0-9])#{Regexp.escape(selector)}(?![-_a-zA-Z0-9])/
+      content.match?(pattern)
+    end
+
+    sig { params(finding: Finding).returns(String) }
+    def format_finding(finding)
+      selector = finding.selector
+      selector_suffix = selector.nil? ? "" : " (#{selector})"
+
+      "- #{finding.rule_name}: #{finding.path}#{selector_suffix} - #{finding.message}"
+    end
+  end
+end

data/lib/hakumi_components/types/form_field.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Types
+    FormFieldName = T.type_alias { StringOrSymbol }
+    FormFieldErrors = T.type_alias { T::Array[String] }
+    FormFieldScalar = T.type_alias do
+      T.nilable(T.any(
+        String,
+        Symbol,
+        T::Boolean,
+        Numeric,
+        Date,
+        Time,
+        DateTime,
+        ActiveSupport::TimeWithZone,
+        ActiveSupport::SafeBuffer
+      ))
+    end
+    FormFieldValue = T.type_alias { T.any(FormFieldScalar, T::Array[FormFieldScalar]) }
+    FormFieldConfig = T.type_alias { T::Hash[Symbol, T.any(String, T::Array[String], FormFieldValue)] }
+  end
+end

data/lib/hakumi_components/types/html.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Types
+    StringOrSymbol = T.type_alias { T.any(String, Symbol) }
+    HtmlScalar = T.type_alias { T.any(StringOrSymbol, T::Boolean, Numeric) }
+    HtmlKey = T.type_alias { StringOrSymbol }
+    HtmlPrimitive = T.type_alias { T.nilable(HtmlScalar) }
+    DataAttributes = T.type_alias { T::Hash[HtmlKey, HtmlPrimitive] }
+    HtmlClassList = T.type_alias { T::Array[T.nilable(String)] }
+    ClassModifierValue = T.type_alias { T.nilable(T.any(StringOrSymbol, T::Boolean)) }
+    StyleMap = T.type_alias { T::Hash[HtmlKey, T.nilable(String)] }
+    StringOrSymbolArray = T.type_alias { T::Array[StringOrSymbol] }
+    HtmlAttributeValue = T.type_alias do
+      T.nilable(T.any(
+        HtmlPrimitive,
+        DataAttributes,
+        HtmlClassList
+      ))
+    end
+
+    HtmlAttributes = T.type_alias { T::Hash[Symbol, HtmlAttributeValue] }
+    StyleValue = T.type_alias { T.any(StyleMap, T::Array[String]) }
+    ClassModifiers = T.type_alias { T::Hash[HtmlKey, ClassModifierValue] }
+    CssClasses = T.type_alias { T.any(T.nilable(String), HtmlClassList) }
+  end
+end

data/lib/hakumi_components/types/rendering.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Types
+    ComponentRenderable = T.type_alias { T.any(ViewComponent::Base, ViewComponent::Slot) }
+    Renderable = T.type_alias { T.nilable(T.any(String, ActiveSupport::SafeBuffer, ViewComponent::Base, ViewComponent::Slot)) }
+    RenderedContent = T.type_alias { T.nilable(T.any(String, ActiveSupport::SafeBuffer)) }
+  end
+end

data/lib/hakumi_components/types/stimulus.rb

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Types
+    StimulusScalar = T.type_alias { T.any(StringOrSymbol, T::Boolean, Numeric) }
+    StimulusArrayValue = T.type_alias { T::Array[T.any(StringOrSymbol, Numeric)] }
+    StimulusObject = T.type_alias { T::Hash[Symbol, T.nilable(T.any(StringOrSymbol, Numeric))] }
+    StimulusObjectArray = T.type_alias { T::Array[StimulusObject] }
+    StimulusValue = T.type_alias { T.nilable(T.any(StimulusScalar, StimulusArrayValue, StimulusObjectArray, StimulusObject)) }
+    StimulusValues = T.type_alias do
+      T::Hash[Symbol, StimulusValue]
+    end
+
+    StimulusData = T.type_alias do
+      T::Hash[String, T.nilable(StimulusScalar)]
+    end
+  end
+end

data/lib/hakumi_components/types/validation.rb

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+module HakumiComponents
+  module Types
+    ValidationPrimitive = T.type_alias { T.any(String, Symbol, T::Boolean, Numeric) }
+    ValidationComparable = T.type_alias { T.any(String, Symbol, Numeric) }
+    ValidationList = T.type_alias { T::Array[ValidationComparable] }
+    MessageOptionValue = T.type_alias { T.nilable(ValidationComparable) }
+    MessageOptions = T.type_alias { T::Hash[Symbol, MessageOptionValue] }
+    ValidationRulePayload = T.type_alias { T::Hash[Symbol, MessageOptionValue] }
+    ComparisonOperand = T.type_alias { T::Hash[Symbol, MessageOptionValue] }
+    ValidatorOptionValue = T.type_alias do
+      T.nilable(T.any(ValidationPrimitive, Regexp, T::Range[Numeric], ValidationList, Proc))
+    end
+    ValidatorOptions = T.type_alias { T::Hash[Symbol, ValidatorOptionValue] }
+
+    ValidationRule = T.type_alias do
+      T::Hash[Symbol, T.nilable(T.any(ValidationPrimitive, ValidationRulePayload, ValidationList))]
+    end
+  end
+end

data/lib/hakumi_components/types.rb

@@ -0,0 +1,13 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "types/html"
+require_relative "types/stimulus"
+require_relative "types/validation"
+require_relative "types/rendering"
+require_relative "types/form_field"
+
+module HakumiComponents
+  module Types
+  end
+end

data/lib/hakumi_components/version.rb

@@ -1,5 +1,6 @@
+# typed: strict
 # frozen_string_literal: true
 
-module Hakumi
-  VERSION = "0.1.17.pre"
+module HakumiComponents
+  VERSION = "0.1.19.pre"
 end

data/lib/hakumi_components.rb

@@ -1,28 +1,49 @@
+# typed: strict
 # frozen_string_literal: true
 
+require "sorbet-runtime"
+require "active_support/time"
 require "view_component"
 require "hakumi_components/version"
-require "hakumi_components/engine"
+require "hakumi_components/types"
+require "hakumi_components/engine" if defined?(::Rails::Engine)
 require "hakumi_components/rails"
 require "hakumi_components/documentation"
 
-module Hakumi
+module HakumiComponents
   class << self
-    def configure
+    extend T::Sig
+
+    sig { params(block: T.proc.params(config: Configuration).void).void }
+    def configure(&block)
       yield configuration
     end
 
+    sig { returns(Configuration) }
     def configuration
+      @configuration = T.let(@configuration, T.nilable(Configuration)) unless instance_variable_defined?(:@configuration)
       @configuration ||= Configuration.new
     end
-    alias config configuration
+
+    sig { returns(Configuration) }
+    def config
+      configuration
+    end
   end
 
   class Configuration
+    extend T::Sig
+
+    sig { returns(String) }
     attr_accessor :base_path
 
+    sig { returns(T::Boolean) }
+    attr_accessor :default_form_builder
+
+    sig { void }
     def initialize
-      @base_path = "hakumi/components"
+      @base_path = T.let("hakumi/components", String)
+      @default_form_builder = T.let(false, T::Boolean)
     end
   end
 end

data/lib/tasks/coverage.rake

@@ -1,3 +1,4 @@
+# typed: false
 # frozen_string_literal: true
 
 namespace :coverage do