hakumi_components 0.1.3.pre

data/app/services/hakumi/icon/loader.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Hakumi
+  module Icon
+    # Loads Ant Design icons from lib/hakumi_components/app/assets/icons
+    class Loader
+      ICONS_BASE_PATH = if defined?(HakumiComponents::Engine)
+        HakumiComponents::Engine.root.join("app", "assets", "icons")
+      else
+        Rails.root.join("app", "assets", "icons")
+      end
+
+      class << self
+        def cache
+          @cache ||= {}
+        end
+
+        def load(name, theme = :outlined)
+          cache_key = "#{name}_#{theme}"
+          return cache[cache_key] if cache.key?(cache_key)
+
+          svg = read_icon_file(name, theme)
+          cache[cache_key] = svg
+          svg
+        end
+
+        def exists?(name, theme = :outlined)
+          !load(name, theme).nil?
+        end
+
+        def list_icons(theme = :outlined)
+          theme_dir = theme_directory(theme)
+          return [] unless theme_dir.exist?
+
+          Dir.glob(theme_dir.join("*.svg")).map do |path|
+            File.basename(path, ".svg").gsub("-", "_")
+          end.sort
+        end
+
+        def clear_cache!
+          @cache = {}
+        end
+
+        private
+
+        def read_icon_file(name, theme)
+          filepath = icon_filepath(name, theme)
+          return nil unless filepath.exist?
+
+          svg_content = File.read(filepath)
+          enhance_svg(svg_content)
+        rescue => e
+          Rails.logger.error("Error loading icon #{name} (#{theme}): #{e.message}")
+          nil
+        end
+
+        def icon_filepath(name, theme)
+          theme_dir = theme_directory(theme)
+          filename = kebabize(name.to_s)
+          theme_dir.join("#{filename}.svg")
+        end
+
+        def theme_directory(theme)
+          theme_str = case theme.to_sym
+          when :outlined then "outlined"
+          when :filled then "filled"
+          when :two_tone, :twotone then "twotone"
+          else "outlined"
+          end
+
+          ICONS_BASE_PATH.join(theme_str)
+        end
+
+        def enhance_svg(svg_content)
+          svg = svg_content.dup
+
+          svg.sub!("<svg", '<svg width="1em"') unless svg.include?("width=")
+          svg.sub!("<svg", '<svg height="1em"') unless svg.include?("height=")
+          svg.sub!("<svg", '<svg fill="currentColor"') unless svg.include?("fill=")
+
+          svg
+        end
+
+        def kebabize(str)
+          str.gsub(/::/, "/")
+             .gsub(/([A-Z]+)([A-Z][a-z])/, '\1-\2')
+             .gsub(/([a-z\d])([A-Z])/, '\1-\2')
+             .tr("_", "-")
+             .downcase
+        end
+      end
+    end
+  end
+end
+HakumiIconLoader = Hakumi::Icon::Loader unless defined?(HakumiIconLoader)

data/app/services/hakumi/illustrations/loader.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Hakumi
+  module Illustrations
+    # Loads SVG illustrations stored under lib/hakumi_components/app/assets/illustrations
+    class Loader
+      ILLUSTRATIONS_PATH = if defined?(HakumiComponents::Engine)
+        HakumiComponents::Engine.root.join("app", "assets", "illustrations")
+      else
+        Rails.root.join("lib", "hakumi_components", "app", "assets", "illustrations")
+      end
+
+      class << self
+        def load(name)
+          filename = "#{name}.svg"
+          cache[filename] ||= read_svg(filename)
+        end
+
+        def clear_cache!
+          @cache = {}
+        end
+
+        private
+
+        def cache
+          @cache ||= {}
+        end
+
+        def read_svg(filename)
+          path = ILLUSTRATIONS_PATH.join(filename)
+          return nil unless path.exist?
+
+          svg = File.read(path)
+          svg.respond_to?(:html_safe) ? svg.html_safe : svg
+        rescue => e
+          Rails.logger.error("Error loading illustration #{filename}: #{e.message}")
+          nil
+        end
+      end
+    end
+  end
+end
+HakumiIllustrationLoader = Hakumi::Illustrations::Loader unless defined?(HakumiIllustrationLoader)

data/app/services/hakumi_components/component_handler.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module HakumiComponents
+  class ComponentHandler
+    def initialize(component, params)
+      @component = component.to_sym
+      @params = params
+    end
+
+    def locals
+      base_locals.merge(specific_locals)
+    end
+
+    private
+
+    def base_locals
+      {
+        id: @params[:id].presence || "hakumi-#{@component}-#{SecureRandom.hex(4)}"
+      }
+    end
+
+    def specific_locals
+      component_class = resolve_component_class
+      return {} unless component_class.respond_to?(:extract_controller_locals)
+
+      component_class.extract_controller_locals(@params)
+    end
+
+    def resolve_component_class
+      case @component
+      when :modal then Hakumi::Modal::Component
+      when :confirm then Hakumi::Modal::Confirm::Component
+      when :alert then Hakumi::Alert::Component
+      when :drawer then Hakumi::Drawer::Component
+      when :message then Hakumi::Message::Component
+      when :notification then Hakumi::Notification::Component
+      when :popover then Hakumi::Popover::Component
+      when :progress then Hakumi::Progress::Component
+      when :result then Hakumi::Result::Component
+      when :skeleton then Hakumi::Skeleton::Component
+      when :spin then Hakumi::Spin::Component
+      when :qr_code then Hakumi::QrCode::Component
+      when :affix then Hakumi::Affix::Component
+      when :segmented then Hakumi::Segmented::Component
+      when :statistic then Hakumi::Statistic::Component
+      when :tag then Hakumi::Tag::Component
+      when :timeline then Hakumi::Timeline::Component
+      when :tree then Hakumi::Tree::Component
+      else nil
+      end
+    end
+  end
+end

data/app/views/hakumi/time_picker/_columns.html.erb

@@ -0,0 +1,73 @@
+<%#
+  Reusable time picker columns partial
+  Used by both TimePicker and DatePicker (with show_time)
+
+  Required locals:
+  - formatted_hours: Array of hour strings
+  - formatted_minutes: Array of minute strings
+  - formatted_seconds: Array of second strings (optional)
+  - show_seconds: Boolean
+  - use_12_hours: Boolean
+  - period_options: Array ["AM", "PM"] (optional)
+  - controller: String - stimulus controller name (e.g., "hakumi--time-picker")
+%>
+
+<div class="hakumi-time-picker-column">
+  <div class="hakumi-time-picker-column-title">Hours</div>
+  <ul class="hakumi-time-picker-column-list">
+    <% formatted_hours.each do |hour| %>
+      <li class="hakumi-time-picker-cell"
+          data-value="<%= hour %>"
+          data-action="click-><%= controller %>#selectHour"
+          data-<%= controller %>-target="hourOption">
+        <%= hour %>
+      </li>
+    <% end %>
+  </ul>
+</div>
+
+<div class="hakumi-time-picker-column">
+  <div class="hakumi-time-picker-column-title">Minutes</div>
+  <ul class="hakumi-time-picker-column-list">
+    <% formatted_minutes.each do |minute| %>
+      <li class="hakumi-time-picker-cell"
+          data-value="<%= minute %>"
+          data-action="click-><%= controller %>#selectMinute"
+          data-<%= controller %>-target="minuteOption">
+        <%= minute %>
+      </li>
+    <% end %>
+  </ul>
+</div>
+
+<% if show_seconds %>
+  <div class="hakumi-time-picker-column">
+    <div class="hakumi-time-picker-column-title">Seconds</div>
+    <ul class="hakumi-time-picker-column-list">
+      <% formatted_seconds.each do |second| %>
+        <li class="hakumi-time-picker-cell"
+            data-value="<%= second %>"
+            data-action="click-><%= controller %>#selectSecond"
+            data-<%= controller %>-target="secondOption">
+          <%= second %>
+        </li>
+      <% end %>
+    </ul>
+  </div>
+<% end %>
+
+<% if use_12_hours && defined?(period_options) %>
+  <div class="hakumi-time-picker-column">
+    <div class="hakumi-time-picker-column-title">Period</div>
+    <ul class="hakumi-time-picker-column-list">
+      <% period_options.each do |period| %>
+        <li class="hakumi-time-picker-cell"
+            data-value="<%= period %>"
+            data-action="click-><%= controller %>#selectPeriod"
+            data-<%= controller %>-target="periodOption">
+          <%= period %>
+        </li>
+      <% end %>
+    </ul>
+  </div>
+<% end %>

data/app/views/hakumi_components/_admin_panel.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::AdminPanel::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_affix.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Affix::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_alert.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Alert::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_confirm.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Modal::Confirm::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_drawer.html.erb

@@ -0,0 +1,3 @@
+<%= render Hakumi::Drawer::Component.new(**local_assigns) do %>
+  <p><%= message %></p>
+<% end %>

data/app/views/hakumi_components/_message.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Message::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_modal.html.erb

@@ -0,0 +1,3 @@
+<%= render Hakumi::Modal::Component.new(**local_assigns) do %>
+  <p><%= message %></p>
+<% end %>

data/app/views/hakumi_components/_notification.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Notification::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_popconfirm.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Popconfirm::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_popover.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Popover::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_qr_code.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::QrCode::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_result.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Result::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_segmented.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Segmented::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_skeleton.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Skeleton::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_spin.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Spin::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_statistic.html.erb

@@ -0,0 +1,13 @@
+<%= render Hakumi::Statistic::Component.new(
+  id: id,
+  title: title,
+  value: value,
+  precision: precision,
+  prefix: prefix,
+  suffix: suffix,
+  animated: animated,
+  duration: duration,
+  countdown: countdown,
+  format: format,
+  aria_label: aria_label
+) %>

data/app/views/hakumi_components/_table.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Table::Component.new(**local_assigns) %>

data/app/views/hakumi_components/_tag.html.erb

@@ -0,0 +1,3 @@
+<%= render Hakumi::Tag::Component.new(**local_assigns.except(:content)) do %>
+  <%= local_assigns[:content] %>
+<% end %>

data/app/views/hakumi_components/_timeline.html.erb

@@ -0,0 +1,16 @@
+<% timeline_locals = local_assigns.except(:items) %>
+<% timeline_items = Array(local_assigns[:items]) %>
+
+<%= render Hakumi::Timeline::Component.new(**timeline_locals) do |timeline| %>
+  <% timeline_items.each do |item| %>
+    <% item = item.with_indifferent_access %>
+    <% content = item.delete(:content) || item.delete(:body) %>
+    <% if content.present? %>
+      <% timeline.with_item(**item) do %>
+        <%= content %>
+      <% end %>
+    <% else %>
+      <% timeline.with_item(**item) %>
+    <% end %>
+  <% end %>
+<% end %>

data/app/views/hakumi_components/_tree.html.erb

@@ -0,0 +1 @@
+<%= render Hakumi::Tree::Component.new(**local_assigns) %>

data/lib/hakumi_components/engine.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module HakumiComponents
+  class Engine < ::Rails::Engine
+    isolate_namespace HakumiComponents
+
+    root = Pathname.new(File.expand_path("../..", __dir__ || "."))
+    config.root = root
+
+    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")
+
+    initializer "hakumi_components.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")
+      end
+    end
+
+    initializer "hakumi_components.views" do |app|
+      app.config.paths["app/views"] << root.join("app/views")
+    end
+  end
+end

data/lib/hakumi_components/rails/attribute_introspection.rb

@@ -0,0 +1,156 @@
+# 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)
+
+          # 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)
+        end
+
+        # Get placeholder text from I18n
+        #
+        # @param object [ActiveModel::Model, ActiveRecord::Base]
+        # @param attribute [Symbol]
+        # @return [String, nil]
+        def placeholder(object, attribute)
+          return nil unless object
+          return nil unless defined?(I18n)
+
+          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]
+        def hint(object, attribute)
+          return nil unless object
+          return nil unless defined?(I18n)
+
+          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.
+        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
+          end
+        end
+
+        # Get database column for attribute
+        #
+        # @param object [ActiveRecord::Base]
+        # @param attribute [Symbol]
+        # @return [ActiveRecord::ConnectionAdapters::Column, nil]
+        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
+        end
+
+        # Check if column is numeric
+        #
+        # @param object [ActiveRecord::Base]
+        # @param attribute [Symbol]
+        # @return [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
+          end
+        end
+
+        # Check if column is text/string
+        #
+        # @param object [ActiveRecord::Base]
+        # @param attribute [Symbol]
+        # @return [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
+          end
+        end
+
+        # Get SQL column limit (for string columns)
+        #
+        # @param object [ActiveRecord::Base]
+        # @param attribute [Symbol]
+        # @return [Integer, nil]
+        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)
+        end
+      end
+    end
+  end
+end