daisyui 2.0.2 → 2.1.1

data/exe/daisyui-tailwind

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "daisyui"
+
+exit DaisyUI::Tailwind::Command.run(ARGV)

data/lib/daisy_ui/base.rb

@@ -118,14 +118,37 @@ module DaisyUI
       error: "bg-error text-error-content"
     }.freeze
 
+    # Component registries: written by the class body (register_modifiers,
+    # register_flags, `self.component_class =`) and by `inherited`, on the main
+    # Ractor while the class loads; rendering only reads them. Every writer
+    # assigns a new value instead of mutating the old one and freezes it as it
+    # writes (Shareable.share), so a non-main Ractor can read the registries of
+    # a component that loaded after boot too, and a later register_* still
+    # works.
     class << self
-      attr_writer :component_class, :modifier_groups, :flags
-      attr_accessor :modifiers
+      # rubocop:disable ThreadSafety/ClassInstanceVariable -- see above
+      attr_reader :modifiers
+
+      def modifiers=(modifiers)
+        @modifiers = Shareable.share(modifiers)
+      end
+
+      def modifier_groups=(groups)
+        @modifier_groups = Shareable.share(groups)
+      end
+
+      def flags=(flags)
+        @flags = Shareable.share(flags)
+      end
+
+      def component_class=(component_class)
+        @component_class = Shareable.share(component_class)
+      end
 
       # Positional symbols a component handles itself (e.g. Dropdown's
       # :popover): accepted as modifiers, but they emit no class.
       def flags
-        @flags ||= []
+        @flags || []
       end
 
       def register_flags(*names)
@@ -135,20 +158,24 @@ module DaisyUI
       # { group => [modifier, ...] }: modifiers in one group are alternatives
       # (sizes, colors, ...), so ClassMerge keeps only the last one.
       def modifier_groups
-        @modifier_groups ||= {}
+        @modifier_groups || {}
       end
 
+      # Derived from the class name on first use, the same value every time.
+      # Remembered on the main Ractor only (DaisyUI.finalize! derives it at
+      # boot); a non-main Ractor cannot set a class ivar, so it derives it.
       def component_class
         return @component_class if instance_variable_defined?(:@component_class)
 
-        @component_class = begin
+        derived = begin
           # Convert "DaisyUI::Button" -> "button"
           class_name = name.split("::").last # demodulize
           class_name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
             .gsub(/([a-z\d])([A-Z])/, '\1_\2')
             .tr("_", "-")
-            .downcase
+            .downcase.freeze
         end
+        Store.main_ractor? ? (@component_class = derived) : derived
       end
 
       def inherited(subclass)
@@ -161,6 +188,7 @@ module DaisyUI
 
         subclass.component_class = @component_class
       end
+      # rubocop:enable ThreadSafety/ClassInstanceVariable
 
       # Registers modifiers. A Hash value declares a group of alternatives:
       #
@@ -178,15 +206,23 @@ module DaisyUI
           end
         end
 
-        modifier_groups.each_value { |members| members.delete_if { |member| flat.key?(member) } }
+        groups = modifier_groups.transform_values { |members| members.reject { |member| flat.key?(member) } }
         mods.each do |group, value|
-          (modifier_groups[group] ||= []).concat(value.keys) if value.is_a?(Hash)
+          groups[group] = (groups[group] || []) + value.keys if value.is_a?(Hash)
         end
-        modifier_groups.delete_if { |_group, members| members.empty? }
 
+        self.modifier_groups = groups.reject { |_group, members| members.empty? }
         self.modifiers = (modifiers || {}).merge(flat)
         ClassMerge.reset!
       end
+
+      # @api private Called by DaisyUI.finalize! for every component: derives
+      # component_class on the main Ractor and makes sure every registry is
+      # frozen for non-main Ractors.
+      def finalize!
+        [component_class, modifiers, modifier_groups, flags].each { |registry| Shareable.share(registry) }
+        self
+      end
     end
 
     def initialize(*modifiers, as: :div, id: nil, **options)

data/lib/daisy_ui/class_merge/configuration.rb

@@ -24,6 +24,20 @@ module DaisyUI
         @conflicts = {}
       end
 
+      def initialize_copy(source)
+        super
+        @theme = @theme.transform_values(&:dup)
+        @class_groups = @class_groups.transform_values(&:dup)
+        @conflicts = @conflicts.transform_values(&:dup)
+      end
+
+      # @api private Called by DaisyUI.finalize!. A raw class group's
+      # validator that closes over app state is kept as it is.
+      def finalize!
+        [@theme, @class_groups, @conflicts].each { |settings| Shareable.share(settings) }
+        freeze
+      end
+
       # Registers utilities that behave like an existing one:
       # `utility("text-display", like: "text-lg")` makes `text-display` a font
       # size, so it replaces `text-sm` and sits next to `text-error`.
@@ -57,11 +71,12 @@ module DaisyUI
         append(@conflicts, conflicts)
       end
 
-      # @api private The config passed to Merger.new, including the daisyUI groups.
-      def merger_config
+      # @api private The config passed to Merger.new, including the daisyUI
+      # groups of +configuration+ (the DaisyUI configuration holding this one).
+      def merger_config(configuration = DaisyUI.configuration)
         {
           theme: @theme,
-          class_groups: DaisyGroups.build.merge(@class_groups) { |_id, existing, added| existing + added },
+          class_groups: DaisyGroups.build(configuration).merge(@class_groups) { |_id, existing, added| existing + added },
           conflicting_class_groups: @conflicts
         }
       end

data/lib/daisy_ui/class_merge/daisy_groups.rb

@@ -18,8 +18,9 @@ module DaisyUI
     # @api private
     module DaisyGroups
       class << self
-        # Class groups for the merger: `{ "daisy:group:btn-size" => ["btn-xs", ...], ... }`.
-        def build(prefix: DaisyUI.configuration.prefix)
+        # Class groups for the merger: `{ "daisy:group:btn-size" => ["btn-xs", ...], ... }`,
+        # from one configuration's prefix and modifiers.
+        def build(configuration = DaisyUI.configuration, prefix: configuration.prefix)
           components = self.components
           groups = {}
 
@@ -37,7 +38,7 @@ module DaisyUI
           end
 
           # Configured modifiers join the component's own group of that name.
-          DaisyUI.configuration.modifiers.groups.each do |(component, group), classes|
+          configuration.modifiers.groups.each do |(component, group), classes|
             owner = component ? component.component_class || component.name : "global"
             add(groups, "daisy:group:#{owner}-#{group}", classes.flat_map(&:split), prefix)
           end
@@ -51,9 +52,11 @@ module DaisyUI
 
         # Every named DaisyUI::Base subclass: the gem's components (eager
         # loaded) and any app component loaded so far. An app component that
-        # loads later resets the merger through `register_modifiers`.
+        # loads later resets the merger through `register_modifiers`. Only the
+        # main Ractor can eager-load; DaisyUI.finalize! did it there before
+        # any other Ractor builds a merger.
         def components
-          Zeitwerk::Loader.eager_load_namespace(DaisyUI)
+          Zeitwerk::Loader.eager_load_namespace(DaisyUI) if Store.main_ractor?
           descendants(DaisyUI::Base).select(&:name)
         end
 

data/lib/daisy_ui/class_merge/tailwind_config.rb

@@ -8,21 +8,6 @@ module DaisyUI
     module TailwindConfig
       include Validators
 
-      class << self
-        private
-
-        # Recursively freezes nested Hash/Array structures so shared config
-        # constants can't be mutated in place. Keys are strings/symbols and are
-        # already immutable, so only values need walking.
-        def deep_freeze(object)
-          case object
-          when Hash then object.each_value { |value| deep_freeze(value) }
-          when Array then object.each { |value| deep_freeze(value) }
-          end
-          object.freeze
-        end
-      end
-
       THEME_KEYS = %w[
         color
         font
@@ -46,8 +31,8 @@ module DaisyUI
       ].freeze
       THEME_KEYS.each do |key|
         const_set("THEME_#{key.upcase.tr('-', '_')}", lambda { |config|
-                                                        config[:theme].fetch(key, nil)
-                                                      }
+          config[:theme].fetch(key, nil)
+        }
         )
       end
 
@@ -2465,7 +2450,12 @@ module DaisyUI
           "selection"
         ]
       }.freeze
-      deep_freeze(DEFAULTS)
+
+      # Every constant above, DEFAULTS deeply, is made Ractor-shareable so a
+      # non-main Ractor can build its own merger from them: the scale and theme
+      # lambdas are capture-free (THEME_* only reads its frozen key) and their
+      # self is this module.
+      constants(false).each { |name| Shareable.make(const_get(name)) }
 
       # Extends DEFAULTS with incoming_config without mutating either.
       # Theme scales are appended. Unlike upstream, `class_groups` and

data/lib/daisy_ui/class_merge/validators.rb

@@ -197,6 +197,10 @@ module DaisyUI
       IS_LABEL_SHADOW = lambda { |label|
         label == "shadow"
       }
+
+      # Ractor-shareable, so a non-main Ractor can read them: every validator
+      # is a capture-free lambda whose self is this module.
+      constants(false).each { |name| Shareable.make(const_get(name)) }
     end
   end
 end

data/lib/daisy_ui/class_merge.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "monitor"
-
 module DaisyUI
   # Merges CSS class lists so that later classes win over earlier conflicting
   # ones, for Tailwind utilities and daisyUI modifiers alike:
@@ -16,10 +14,10 @@ module DaisyUI
   module ClassMerge
     TAILWIND_MERGE_VERSION = "1.5.6"
 
-    # Reentrant, so a reset! triggered while the merger is being built (e.g. a
-    # component file configuring DaisyUI as it loads) cannot deadlock.
-    @monitor = Monitor.new
-
+    # The merger (with its LRU) and the Tailwind class groups live in
+    # DaisyUI::Store: one per Ractor, built on first use under the store's
+    # reentrant lock, so a reset! triggered while the merger is being built
+    # (e.g. a component file configuring DaisyUI as it loads) cannot deadlock.
     class << self
       # Accepts strings, nested arrays, nil and false (dropped, as Phlex does
       # for `class:`). Returns a frozen String, "" when empty.
@@ -27,20 +25,33 @@ module DaisyUI
         merger.merge(parts.flatten.select(&:itself).join(" "))
       end
 
+      # Each Ractor's merger remembers the configuration it was built from
+      # and is rebuilt once DaisyUI.configure publishes another, also in a
+      # Ractor where reset! never ran.
       def merger
-        @merger || @monitor.synchronize do
-          @merger ||= Merger.new(config: DaisyUI.configuration.class_merge.merger_config)
-        end
+        configuration = DaisyUI.configuration
+        built_for, merger = Store.fetch(:daisy_ui_class_merger) { build_merger(configuration) }
+        return merger if built_for.equal?(configuration)
+
+        Store.delete(:daisy_ui_class_merger)
+        Store.fetch(:daisy_ui_class_merger) { build_merger(configuration) }.last
       end
 
       # @api private The stock Tailwind class groups, for classifying tokens.
       def tailwind_utils
-        @tailwind_utils ||= ClassGroupUtils.new(TailwindConfig::DEFAULTS)
+        Store.fetch(:daisy_ui_tailwind_utils) { ClassGroupUtils.new(TailwindConfig::DEFAULTS) }
       end
 
-      # Drops the memoized merger so the next merge picks up configuration changes.
+      # Drops the current Ractor's merger so its next merge picks up
+      # configuration changes.
       def reset!
-        @monitor.synchronize { @merger = nil }
+        Store.delete(:daisy_ui_class_merger)
+      end
+
+      private
+
+      def build_merger(configuration)
+        [configuration, Merger.new(config: configuration.class_merge.merger_config(configuration))]
       end
     end
   end

data/lib/daisy_ui/configurable/report_log.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Configurable
+    # @api private The unknown modifiers already reported, so :warn and a
+    # callable fire once per key. Remembers up to `limit` keys, then starts
+    # over, so modifiers built from user input cannot grow it without bound.
+    # One per Ractor (DaisyUI::Store), so its Mutex is never shared.
+    class ReportLog
+      def initialize(limit)
+        @limit = limit
+        @keys = Set.new
+        @lock = Mutex.new
+      end
+
+      # True the first time a key is seen.
+      def first?(key)
+        @lock.synchronize do
+          return false if @keys.include?(key)
+
+          @keys.clear if @keys.size >= @limit
+          @keys.add(key)
+          true
+        end
+      end
+
+      def clear
+        @lock.synchronize { @keys.clear }
+      end
+
+      def size
+        @lock.synchronize { @keys.size }
+      end
+    end
+  end
+end

data/lib/daisy_ui/configurable.rb

@@ -2,15 +2,45 @@
 
 module DaisyUI
   module Configurable
+    # Created when DaisyUI extends this module, at load, so `configuration` is
+    # a plain read with no check-then-set race.
+    def self.extended(base)
+      base.instance_variable_set(:@configuration, Configuration.new)
+    end
+
+    # Yields a writable copy of the configuration, then finalizes the copy
+    # (see finalize!) and publishes it. Calling configure again keeps
+    # working, no reader (another thread, a non-main Ractor) meets a
+    # half-changed or writable configuration, and a block that raises
+    # publishes nothing. Calls are serialized, so each starts from what the
+    # previous one published.
     def configure
-      self.configuration ||= Configuration.new
-      yield(configuration) if block_given?
-      ClassMerge.reset!
-      configuration
+      configure_lock.synchronize do
+        draft = configuration.dup
+        yield(draft) if block_given?
+        @configuration = draft.finalize!
+        ClassMerge.reset!
+        finalize!
+        configuration
+      end
     end
 
     def configuration
-      @configuration ||= Configuration.new
+      @configuration
+    end
+
+    # Freezes what a non-main Ractor reads (this configuration and every
+    # component's registries) so DaisyUI::ClassMerge.merge runs in any Ractor.
+    # configure calls it, and the Rails engine calls it once the app has
+    # booted; an app with neither calls it at the end of boot. Afterwards
+    # change settings only through configure: writing to the frozen
+    # configuration raises. A configured value that cannot be made shareable
+    # is kept as it is (see Shareable.share), never raised on.
+    def finalize!
+      ClassMerge::DaisyGroups.components.each(&:finalize!)
+      configuration.finalize!
+      ClassMerge.tailwind_utils
+      self
     end
 
     class Modifiers
@@ -19,6 +49,19 @@ module DaisyUI
         @groups = {}
       end
 
+      def initialize_copy(source)
+        super
+        @modifiers = @modifiers.transform_values(&:dup)
+        @groups = @groups.dup
+      end
+
+      # @api private Called by DaisyUI.finalize!.
+      def finalize!
+        Shareable.share(@modifiers)
+        Shareable.share(@groups)
+        freeze
+      end
+
       # `group:` makes the modifier an alternative to the component's other
       # modifiers in that group, e.g. `add(:huge, classes: "btn-xl",
       # component: DaisyUI::Button, group: :size)`.
@@ -59,8 +102,24 @@ module DaisyUI
 
       def initialize
         @prefix = nil
-        @reported_unknown_modifiers = Set.new
-        @reported_unknown_modifiers_lock = Mutex.new
+      end
+
+      def initialize_copy(source)
+        super
+        @class_merge = @class_merge&.dup
+        @modifiers = @modifiers&.dup
+      end
+
+      # @api private Called by DaisyUI.configure and DaisyUI.finalize!. A
+      # callable unknown_modifiers that cannot be made shareable (a lambda
+      # that closes over app state, an object holding a logger) is kept: the
+      # configuration is then frozen but readable on the main Ractor only.
+      def finalize!
+        class_merge.finalize!
+        modifiers.finalize!
+        Shareable.share(@prefix)
+        Shareable.share(@unknown_modifiers)
+        freeze
       end
 
       # What a component does with a positional modifier it does not know:
@@ -94,7 +153,7 @@ module DaisyUI
 
       # @api private
       def reset_reported_unknown_modifiers!
-        @reported_unknown_modifiers_lock.synchronize { @reported_unknown_modifiers.clear }
+        reported_unknown_modifiers.clear
       end
 
       def prefix=(prefix)
@@ -112,16 +171,14 @@ module DaisyUI
 
       private
 
-      # Remembers up to REPORTED_UNKNOWN_MODIFIERS_LIMIT keys, then starts over,
-      # so modifiers built from user input cannot grow it without bound.
       def first_report?(key)
-        @reported_unknown_modifiers_lock.synchronize do
-          return false if @reported_unknown_modifiers.include?(key)
+        reported_unknown_modifiers.first?(key)
+      end
 
-          @reported_unknown_modifiers.clear if @reported_unknown_modifiers.size >= REPORTED_UNKNOWN_MODIFIERS_LIMIT
-          @reported_unknown_modifiers.add(key)
-          true
-        end
+      # What was already reported lives per Ractor, outside the configuration,
+      # which stays shareable.
+      def reported_unknown_modifiers
+        Store.fetch(:daisy_ui_reported_unknown_modifiers) { ReportLog.new(REPORTED_UNKNOWN_MODIFIERS_LIMIT) }
       end
 
       def default_unknown_modifiers
@@ -130,5 +187,13 @@ module DaisyUI
         %w[development test].include?(::Rails.env.to_s) ? :raise : :warn
       end
     end
+
+    private
+
+    # Reentrant, and one per Ractor (DaisyUI::Store) so it is never shared;
+    # configure writes DaisyUI's ivar, so only the main Ractor gets that far.
+    def configure_lock
+      Store.fetch(:daisy_ui_configure_lock) { Monitor.new }
+    end
   end
 end

data/lib/daisy_ui/engine.rb

@@ -34,6 +34,13 @@ module DaisyUI
       precompile.concat(MINIFIED_ASSETS) if precompile.is_a?(Array)
     end
 
+    # Once the app has booted, freeze the configuration and component
+    # registries so a non-main Ractor can merge classes. DaisyUI.configure in
+    # an initializer already finalized; this also covers an app that never
+    # calls it and the components loaded during boot (eager loading).
+    # DaisyUI.configure keeps working afterwards, on a copy.
+    config.after_initialize { DaisyUI.finalize! }
+
     initializer "daisy_ui.importmap", before: "importmap" do |app|
       next unless app.config.respond_to?(:importmap)
 

data/lib/daisy_ui/mcp_server.rb

@@ -39,6 +39,7 @@ module DaisyUI
         }
       }
     ].freeze
+    Shareable.make(TOOLS) # the Hashes inside too
 
     EXCLUDED_CONSTANTS = %i[Base Configurable Configuration Modifiers VERSION UPDATED_AT McpServer].freeze
 

data/lib/daisy_ui/shareable.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  # @api private Deep-freezes a value so a non-main Ractor can read it from a
+  # constant or a class ivar: `Ractor.make_shareable`, or, on engines without
+  # Ractor (JRuby, TruffleRuby), a walk freezing Hash values and Array elements.
+  module Shareable
+    class << self
+      # For the gem's own literals, which must all be shareable: raises if one
+      # is not.
+      def make(value)
+        ractor? ? ::Ractor.make_shareable(value) : deep_freeze(value)
+      end
+
+      # For what an app configures. Freezes Hashes, Arrays and Strings all the
+      # way down, makes a capture-free Proc shareable, and keeps anything else
+      # (a Proc that closes over app state, a logger) as it is, so whatever
+      # holds it is readable on the main Ractor only. Never raises, and never
+      # hands an object it does not know to Ractor.make_shareable, which
+      # freezes as it goes and would leave a logger frozen before failing.
+      def share(value)
+        case value
+        when Hash
+          value.each do |key, member|
+            share(key)
+            share(member)
+          end.freeze
+        when Array then value.each { |member| share(member) }.freeze
+        when String then value.freeze
+        when Proc then share_proc(value)
+        else value
+        end
+      end
+
+      def ractor?
+        defined?(::Ractor) ? ::Ractor.respond_to?(:make_shareable) : false
+      end
+
+      private
+
+      def share_proc(callable)
+        ractor? ? ::Ractor.make_shareable(callable) : callable
+      rescue ::Ractor::Error, ArgumentError
+        callable
+      end
+
+      def deep_freeze(value)
+        case value
+        when Hash then value.each_value { |member| deep_freeze(member) }
+        when Array then value.each { |member| deep_freeze(member) }
+        end
+        value.freeze
+      end
+    end
+  end
+end

data/lib/daisy_ui/store.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module DaisyUI
+  # @api private Per-Ractor lazy storage for caches that must not live in a
+  # class ivar or a constant (the class-merge merger, the Tailwind class
+  # groups, the unknown-modifier report log):
+  #
+  #   DaisyUI::Store.fetch(:daisy_ui_merger) { Merger.new(...) }
+  #   DaisyUI::Store.delete(:daisy_ui_merger)
+  #
+  # Adapted from conformance-kit's ConformanceKit::Store (MIT, same author),
+  # which daisyui cannot depend on at runtime, plus `delete`. Every Ractor has
+  # its own Monitor-guarded table: reentrant, so an initializer may fetch or
+  # delete other keys. On Ruby 3.4+ the table comes from
+  # `Ractor.store_if_absent`. Below 3.4 the main Ractor's table is created at
+  # load (never lazily, so there is no check-then-set race), and a non-main
+  # Ractor keeps its own in Ractor-local storage.
+  module Store
+    # One Ractor's values. Reads skip the lock once a key is stored.
+    class Table
+      def initialize
+        @monitor = Monitor.new
+        @values = {}
+      end
+
+      def fetch(key)
+        @values.fetch(key) do
+          @monitor.synchronize { @values.fetch(key) { @values[key] = yield } }
+        end
+      end
+
+      def delete(key)
+        @monitor.synchronize { @values.delete(key) }
+      end
+    end
+
+    class << self
+      def fetch(key, &init)
+        raise ArgumentError, "DaisyUI::Store.fetch(#{key.inspect}) needs an initializer block" unless init
+
+        table.fetch(key, &init)
+      end
+
+      def delete(key)
+        table.delete(key)
+      end
+
+      def main_ractor?
+        !defined?(::Ractor) || ::Ractor.current == ::Ractor.main
+      end
+
+      def native?
+        defined?(::Ractor) ? ::Ractor.respond_to?(:store_if_absent) : false
+      end
+
+      private
+
+      def table
+        return ::Ractor.store_if_absent(:daisy_ui_store) { Table.new } if native?
+        return ::Ractor.current[:daisy_ui_store] ||= Table.new unless main_ractor?
+
+        # Set once below, at load, below Ruby 3.4; only the main Ractor reads it.
+        @main_table # rubocop:disable ThreadSafety/ClassInstanceVariable
+      end
+    end
+
+    @main_table = Table.new unless native?
+  end
+end

data/lib/daisy_ui/tailwind/candidate.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module DaisyUI
+  module Tailwind
+    # Which words can go into Tailwind's `@source inline("…")`. inline() is a
+    # quoted string with brace expansion, and one unbalanced bracket in it
+    # makes Tailwind drop every class after it, so a candidate starts and ends
+    # like a utility or variant, has balanced () and [], and holds no quote,
+    # brace, semicolon, backslash or backtick. A `/` only introduces a
+    # fraction or an opacity (`w-1/2`, `bg-base-100/50`), never a path.
+    #
+    # @api private
+    module Candidate
+      SHAPE = /\A[a-z@!\[*-][^\s"'`;{}\\]*[a-z0-9\])%!]\z/
+      PATH = %r{/(?![0-9\[])}
+      CLOSING = { ")" => "(", "]" => "[" }.freeze
+
+      class << self
+        def valid?(token)
+          SHAPE.match?(token) && token.match?(/[a-z]/) && !PATH.match?(token) && balanced?(token)
+        end
+
+        # The candidates among the whitespace-separated words of `classes`.
+        def tokens(classes)
+          classes.split.select { |token| valid?(token) }
+        end
+
+        private
+
+        def balanced?(token)
+          open = []
+          token.each_char do |char|
+            if CLOSING.value?(char)
+              open << char
+            elsif CLOSING.key?(char)
+              return false unless open.pop == CLOSING[char]
+            end
+          end
+          open.empty?
+        end
+      end
+    end
+  end
+end